Come usare una classe da un progetto C # con un altro progetto C #

Nella stessa soluzione, ho due progetti: P1 e P2. Come posso utilizzare una classe P1 in P2?

Aggiungere semplicemente il riferimento a P1 da P2

1. Nella struttura "Esplora soluzioni", espandi il progetto P2, quindi fai clic con il pulsante destro del mouse sul progetto e seleziona "Aggiungi riferimento" dal menu.
2. Nella finestra di dialogo "Aggiungi riferimento", seleziona la scheda "Progetti" e seleziona il tuo progetto P1.
3. Se stai usando gli spazi dei nomi, dovrai importare gli spazi dei nomi per i tuoi tipi P1 aggiungendo istruzioni "using" ai tuoi file in P2.

Notare che i tipi in P1 a cui si desidera accedere direttamente devono avere un livello di accesso sufficiente: in genere questo significa che devono essere resi pubblici.

Paul Ruane ha ragione, ho appena provato a costruire il progetto. Ho appena creato un intero SLN per verificare se funzionava.

L'ho fatto in VC # VS2008

<< (Sto solo aiutando altre persone che leggono questo e con i commenti ())

Passo 1:

Crea una soluzione chiamata DoubleProject

Passo 2:

Crea progetto in una soluzione denominata DoubleProjectTwo (per fare ciò selezionare il file della soluzione, fare clic con il tasto destro -> Aggiungi -> Nuovo progetto)

Ora ho due progetti nella stessa soluzione

Fase 3:

Come ha affermato Paul Ruane. vai ai riferimenti in Esplora soluzioni (se chiuso è nella scheda Visualizza del compilatore). DoubleProjectTwo è quello che necessita di funzioni / metodi di DoubleProject, quindi in DoubleProjectTwo il riferimento destro del mouse è presente -> Aggiungi -> Progetti -> DoubleProject.

Fase 4:

Includere la direttiva per lo spazio dei nomi:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DoubleProject; <------------------------------------------

namespace DoubleProjectTwo
{
    class ClassB
    {
        public string textB = "I am in Class B Project Two";
        ClassA classA = new ClassA();


        public void read()
        {
            textB = classA.read();
        }
    }
}

Fase 5:

Fai qualcosa che mi mostri la prova dei risultati:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DoubleProject
{
    public class ClassA    //<---------- PUBLIC class
    {
        private const string textA = "I am in Class A Project One";

        public string read()
        {
            return textA;
        }
    }
}

Il principale

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DoubleProjectTwo;  //<----- to use ClassB in the main

namespace DoubleProject
{
    class Program
    {
        static void Main(string[] args)
        {
            ClassB foo = new ClassB();

            Console.WriteLine(foo.textB);
            Console.ReadLine();
        }
    }
}

Questo DOVREBBE fare il trucco

Spero che questo ti aiuti

EDIT ::: whoops ha dimenticato la chiamata al metodo per cambiare effettivamente la stringa, non fare lo stesso :)

Troppo spesso un nuovo sviluppatore pone questa semplice domanda che è un problema comune in particolare con gli IDE di Visual Studio. Poche persone rispondono alla domanda specifica e spesso criticano la domanda o danno "supposizioni" per soluzioni che non rispondono ai problemi comuni. Il primo problema comune è che l'IDE ti porta a creare nuovi progetti piuttosto che aggiungere nuovi file (.java, .py, .cpp, .c) alla soluzione esistente (per impostazione predefinita crea una nuova soluzione) a meno che tu non modifichi il nome del progetto e aggiungere alla soluzione corrente. Questo problema si verifica per le cartelle di progetto Python, java, c #, C ++ e C.

Ciò non accade quando si aggiunge un altro progetto utilizzando i comandi new> project> project type dell'IDE. Il problema qui è che il nuovo progetto è archiviato in una directory diversa rispetto ai file di codice dell'interfaccia client o utente esistenti. Per creare un nuovo "file" nello stesso spazio di progetto piuttosto che un nuovo progetto, il principiante deve eseguire le seguenti operazioni che Microsoft non farà per te e ti fuorvia dall'intuitivo ovvio per impostazione predefinita.

1. Seleziona l '"applicazione" in cui vuoi importare il nuovo comportamento (da un altro file)
2. Seleziona progetto> aggiungi nuovo elemento
3. Seleziona il "tipo di modello di file di programma" come filetype.py, filetype.java, filetype.c, filetype.cpp, filetype.C #, ecc. O un tipo di file di classe della libreria (qualcosa di diverso dalle opzioni del file di avvio che vedi quando crei un nuovo progetto applicativo o creare un nuovo progetto libreria).
4. Nel progetto viene creato un nuovo nome file con nome predefinito.
5. Cambia il nome predefinito del file in qualcosa come library.py o façade.java, ecc.

ORA i consigli sul codice per importare librerie o utilizzare gli spazi dei nomi funzioneranno come descritto nei commenti sopra e non è necessario modificare le istruzioni del percorso o modificare i percorsi delle soluzioni e i nomi delle soluzioni che Microsoft non ti consente di modificare facilmente (ovvero puoi modificare il nomi di file o nomi di progetto ma l'IDE non cambierà automaticamente il percorso del progetto oi nomi del percorso della soluzione).

Quello che segue è un esempio di Python ma funziona in modo simile per C #, java o C / C ++ utilizzando gli include, gli spazi dei nomi o utilizzando i comandi di codice appropriati per ogni lingua per trovare il codice in altre classi / progetti nello STESSO SPAZIO DI DIRECTORY.

Il file dell'applicazione "ciao mondo" che importa da altri file di codice nella stessa directory.

Nota che i delimitatori di spazio bianco di Python non verranno spaziati correttamente in questo editor di commenti di stackoverflow:

print ("test")

from CIXMPythonFacade import ClassA

c1=ClassA
c1.methodA()

from CIXMPythonFacade import functionA 

functionA()


class ClassName(object): 
         def __init__(object, parameter):
         object.parameter = value

Il file della libreria o il file "façade" contenente classi, metodi o funzioni che si desidera importare.

class class1(object):
    """description of class"""

class ClassA(object):
    print ("test2")
    def methodA():
        print ("test3")

def functionA ():
    print ("test4")
    return (0)


pass

ORA come risolvi effettivamente il casino in cui ti porta l'IDE? Per importare codice da un altro file nello stesso spazio di directory, aggiungi un riferimento ad esso.

1. Seleziona il file dell'applicazione
2. Seleziona Progetto> aggiungi riferimento
3. Scegli il nome del file visibile con il percorso della directory corretto (controllalo)
4. Il riferimento è ora disponibile per l'interprete, il controllore del codice e / o il compilatore.

OK, quindi ora che hai risolto questo problema, come puoi davvero collegare due progetti separati nello stesso spazio di soluzione?

1. Devi andare alle opzioni dell'indicizzatore o "intellisense" e del compilatore / interprete e controllare fisicamente o modificare / aggiungere le istruzioni del percorso della directory se sono qualcosa di diverso da ciò che punta al tuo "secondo" progetto o spazio di soluzione. Quando si apportano modifiche al percorso o si modificano le variabili del percorso nel proprio spazio di lavoro e nelle posizioni specifiche dei progetti che sono spazi di directory diversi, il compilatore e l'analizzatore di codice possono quindi trovare queste librerie, headers.h, spazi dei nomi, percorsi di progetto o file.
2. Rimuovere i vecchi progetti che hai creato per errore è ancora peggio. Devi uscire dall'IDE di Visual Studio, aprire Windows Explorer, andare nella directory dello spazio di lavoro ... documenti \ visualstudio xxx \ nome soluzione \ nomepacchetto selezionare il file o la cartella, fare clic con il tasto destro e "eliminare" il file o la cartella.
3. Quando si reinserisce l'IDE e si seleziona la soluzione aperta o il pacchetto / soluzione aperto, i vecchi file e nomi di soluzione / pacchetto sono spariti così come le loro dichiarazioni di percorso fuorvianti che ingannano il compilatore e l'analizzatore di codice a guardare la vecchia directory anche se hai cambiato il nome del file e ha cambiato il nome del progetto, non cambia il percorso della directory con esso.

Microsoft ha davvero, davvero bisogno di risolvere questi problemi in modo da poter creare intuitivamente ciò che la maggior parte delle persone desidera creare come nuovi file nelle stesse directory e rimuovere le soluzioni selezionandole ed eliminandole dall'IDE. I principianti sono così frustrati dalle istruzioni del percorso della directory così flessibili per gli sviluppatori esperti, ma così ingiuste nei confronti dei nuovi sviluppatori nelle loro impostazioni predefinite.

Spero che questo aiuti davvero voi nuovi ragazzi e impedisca agli sviluppatori esperti di darvi le risposte sbagliate che non funzionano per voi. Presumono che tu abbia già compreso le istruzioni del percorso e che tu voglia semplicemente digitare il codice giusto ... che è anche il motivo per cui il tunnel tenta di correggere il tuo codice ma non ti aiuta a risolvere il problema. Questo è probabilmente il problema più comune continuamente descritto su stackoverflow con risposte sbagliate che non funzionano per i nuovi programmatori.

Il primo passo è fare in modo che P2 faccia riferimento a P1 procedendo come segue

• Fare clic con il tasto destro sul progetto e selezionare "Aggiungi riferimento"
• Vai alla scheda Progetti
• Seleziona P1 e premi OK

Successivamente dovrai assicurarti che le classi in P1 siano accessibili a P2. Il modo più semplice è realizzarli public.

public class MyType { ... }

Ora dovresti essere in grado di usarli in P2 tramite il loro nome completo. Supponendo che lo spazio dei nomi di P1 sia Project1, allora funzionerebbe quanto segue

Project1.MyType obj = new Project1.MyType();

Il modo preferito però è aggiungere un utilizzo per in Project1modo da poter utilizzare i tipi senza qualificazione

using Project1;
...

public void Example() {
  MyType obj = new MyType();
}

Se hai due progetti in una cartella della soluzione, aggiungi semplicemente il riferimento del progetto in un'altra, usando lo spazio dei nomi puoi ottenere le classi. Durante la creazione dell'oggetto per quello la classe richiesta. Chiama il metodo che desideri.

FirstProject:

class FirstClass()
{
   public string Name()
   {
      return "James";
   }
}

Qui aggiungi il riferimento al Secondo Progetto

SecondProject:

class SeccondClass
{
    FirstProject.FirstClass obj=new FirstProject.FirstClass();
    obj.Name();
}

Nel progetto P1 rendi pubblica la classe (se non lo è già). Quindi aggiungi un riferimento al progetto (piuttosto che un riferimento al file, un errore che ho riscontrato occasionalmente) a P2. Aggiungi un'istruzione using in P2 nella posizione corretta e inizia a utilizzare la classe da P1.

(Per menzionare questo: l'alternativa per rendere pubblica la classe sarebbe rendere P2 un amico di P1. Questa, tuttavia, è improbabile che sia la risposta che cerchi in quanto avrebbe alcune conseguenze. Quindi attieniti al suggerimento di cui sopra.)

Supponiamo che la tua classe nel progetto 2 si chiami MyClass.

Ovviamente, prima fai riferimento al tuo progetto 2 sotto i riferimenti nel progetto 1, quindi

using namespaceOfProject2;

// for the class calling bit:

namespaceOfProject2.MyClass project2Class = new namespaceOfProject2.MyClass();

quindi ogni volta che vuoi fare riferimento a quella classe digita project2Class. Inoltre assicurati che anche quella classe sia pubblica.

Ho avuto un problema con diversi framework di destinazione.

Stavo facendo tutto bene, ma non potevo usare il riferimento in P2. Dopo aver impostato lo stesso framework di destinazione per P1 e P2, ha funzionato a meraviglia.

Spero che possa aiutare qualcuno