Como você compartilha código entre projetos / soluções no Visual Studio?

Eu tenho duas soluções que têm algum código comum, então eu gostaria de extraí-lo e compartilhá-lo entre eles. Além disso, eu gostaria de poder liberar essa biblioteca independentemente, pois pode ser útil para outras pessoas.

• Qual é a melhor maneira de fazer isso com o Visual Studio 2008?
• Um projeto está presente em mais de uma solução?
• Tenho uma solução separada para o trecho de código separado?
• Uma solução pode depender de outra?

Um projeto pode ser referenciado por várias soluções.

Coloque sua biblioteca ou código principal em um projeto e faça referência a esse projeto nas duas soluções.

Você pode "vincular" um arquivo de código entre dois projetos. Clique com o botão direito do mouse no seu projeto, escolha Add-> Existing iteme, em seguida, clique na seta para baixo ao lado do Addbotão:

Na minha experiência, vincular é mais simples do que criar uma biblioteca. O código vinculado resulta em um único executável com uma única versão.

File > Add > Existing Project...permitirá adicionar projetos à sua solução atual. Apenas adicionando isso, pois nenhuma das postagens acima indica isso. Isso permite incluir o mesmo projeto em várias soluções.

Você pode incluir um projeto em mais de uma solução. Eu não acho que um projeto tenha um conceito de qual solução ele faz parte. No entanto, outra alternativa é criar a primeira solução em algum lugar conhecido e fazer referência aos binários compilados. Isso tem a desvantagem de que você precisará fazer um pouco de trabalho se desejar fazer referência a versões diferentes com base no fato de criar ou não em configurações de liberação ou depuração.

Não acredito que você possa fazer uma solução realmente depender de outra, mas você pode executar suas compilações automatizadas em uma ordem apropriada por meio de scripts personalizados. Trate basicamente sua biblioteca comum como se fosse outra dependência de terceiros, como NUnit etc.

Você pode fazer curingas embutidos usando a seguinte técnica (que é a maneira pela qual a solução do @ Andomar é salva no .csproj)

<Compile Include="..\MySisterProject\**\*.cs">
  <Link>_Inlined\MySisterProject\%(RecursiveDir)%(Filename)%(Extension)</Link>
</Compile>

Coloque em:

    <Visible>false</Visible>

Se você deseja ocultar os arquivos e / ou impedir que o curinga inclua a expansão, se você adicionar ou remover um item de uma pasta 'item existente virtual', como MySisterProjectacima.

Você simplesmente criaria um projeto separado da Biblioteca de Classes para conter o código comum. Ele não precisa fazer parte de nenhuma solução que o utilize. Faça referência à biblioteca de classes de qualquer projeto que precise.

O único truque é que você precisará usar uma referência de arquivo para fazer referência ao projeto, pois ele não fará parte das soluções que se referem a ele. Isso significa que o conjunto de saída real deverá ser colocado em um local que possa ser acessado por qualquer pessoa que esteja criando um projeto que faça referência a ele. Isso pode ser feito colocando a montagem em um compartilhamento, por exemplo.

Você pode incluir o mesmo projeto em mais de uma solução, mas é garantido que há problemas no futuro (caminhos relativos podem se tornar inválidos quando você move diretórios, por exemplo)

Depois de anos lutando com isso, finalmente cheguei a uma solução viável, mas exige que você use o Subversion para controle de fonte (o que não é uma coisa ruim)

No nível do diretório da sua solução, adicione uma propriedade svn: externals apontando para os projetos que você deseja incluir na sua solução. O Subversion extrairá o projeto do repositório e o armazenará em uma subpasta do seu arquivo de solução. Seu arquivo de solução pode simplesmente usar caminhos relativos para se referir ao seu projeto.

Se eu encontrar mais tempo, explicarei isso em detalhes.

Extraia o código comum em um projeto de biblioteca de classes e adicione esse projeto de biblioteca de classes às suas soluções. Em seguida, você pode adicionar uma referência ao código comum de outros projetos, adicionando uma referência de projeto a essa biblioteca de classes. A vantagem de ter uma referência de projeto em oposição a uma referência de binário / montagem é que, se você alterar sua configuração de compilação para depuração, liberação, customização etc., o projeto da biblioteca de classes comuns também será construído com base nessa configuração.

É uma boa idéia criar uma biblioteca de classes DLL que contenha todas as funcionalidades comuns. Cada solução pode fazer referência a essa DLL independentemente, independentemente de outras soluções.

De fato, é assim que nossas fontes estão organizadas em meu trabalho (e acredito em muitos outros lugares).

A propósito, a Solução não pode depender explicitamente de outra solução.

Duas etapas principais envolvidas são

1- Criando uma DLL C ++

No visual studio

New->Project->Class Library in c++ template. Name of project here is first_dll in 
visual studio 2010. Now declare your function as public in first_dll.h file and 
write the code in first_dll.cpp file as shown below.

Código do arquivo de cabeçalho

// first_dll.h

using namespace System;

namespace first_dll 
{

public ref class Class1
{
public:
    static double sum(int ,int );
    // TODO: Add your methods for this class here.
};
}

Arquivo Cpp

//first_dll.cpp
#include "stdafx.h"

#include "first_dll.h"

namespace first_dll
{

    double Class1:: sum(int x,int y)
    {
        return x+y;
    }

 }

Verifique isto

**Project-> Properties -> Configuration/General -> Configuration Type** 

essa opção deve ser Biblioteca Dinâmica (.dll) e criar a solução / projeto agora.

O arquivo first_dll.dll é criado na pasta Debug

2- Vinculando-o no projeto C #

Projeto C # aberto

Rightclick on project name in solution explorer -> Add -> References -> Browse to path 
where first_dll.dll is created and add the file.

Adicione esta linha na parte superior do projeto C #

Using first_dll; 

Agora, a função dll pode ser acessada usando a instrução abaixo em alguma função

double var = Class1.sum(4,5);

Criei dll no projeto c ++ no VS2010 e usei-o no projeto VS2013 C #. Funciona bem.

Você pode hospedar um servidor NuGet interno e compartilhar as bibliotecas comuns que serão compartilhadas em outros projetos, interna e externamente.

Mais adiante nesta leitura

Se você estiver tentando compartilhar código entre dois tipos diferentes de projetos (ou seja: projeto de área de trabalho e projeto móvel), consulte a pasta de soluções compartilhadas . Eu tenho que fazer isso no meu projeto atual, pois os projetos para dispositivos móveis e computadores exigem classes idênticas que estão apenas em um arquivo. Se você seguir esse caminho, qualquer um dos projetos que tiverem o arquivo vinculado poderá fazer alterações e todos os projetos serão reconstruídos com base nessas alterações.

Há um bom argumento para usar "adicionando links de arquivos existentes" ao reutilizar código em projetos e é quando você precisa fazer referência e oferecer suporte a diferentes versões de bibliotecas dependentes.

Não é fácil fazer vários assemblies com referências a diferentes assemblies externos, sem duplicar o código ou utilizar truques com controle de código-fonte.

Eu acredito que é mais fácil manter um projeto para desenvolvimento e teste de unidade e, em seguida, criar projetos de 'construção' usando links de arquivos existentes quando você precisar criar os assemblies que fazem referência a versões diferentes desses assemblies externos.

Uma maneira mais simples de incluir um arquivo de classe de um projeto em outros projetos é Adicionando o projeto na solução existente e Adicionando a referência DLL do novo projeto no projeto existente. Finalmente, você pode usar os métodos da classe adicionada decalcando usando diretiva na parte superior de qualquer classe.

A partir do VisualStudio 2015, se você mantiver todo o seu código em uma solução, poderá compartilhar o código adicionando um projeto compartilhado . Em seguida, adicione uma referência a este projeto compartilhado para cada projeto em que você deseja usar o código, bem como as diretrizes de uso adequadas.

Agora você pode usar o Projeto Compartilhado

Projeto compartilhado é uma ótima maneira de compartilhar código comum em vários aplicativos. Já experimentamos o tipo de projeto compartilhado no Visual Studio 2013 como parte do Windows 8.1 Universal App Development, mas com o Visual Studio 2015, é um novo modelo de projeto independente; e podemos usá-lo com outros tipos de aplicativos, como console, desktop, telefone, aplicativo da loja etc. Este tipo de projeto é extremamente útil quando queremos compartilhar um código, lógica e componentes comuns em vários aplicativos em uma única plataforma . Isso também permite acessar as APIs específicas da plataforma, ativos etc.

para mais informações verifique isto