C# de l'importation de classe dans une autre classe ne fonctionne pas

Je suis assez novice en C#, et ont fait une classe que je voudrais utiliser dans ma classe principale. Ces deux classes sont dans des fichiers différents, mais lorsque j'essaie d'importer un dans l'autre avec using, cmd dit dit

Le type ou le nom d'espace de noms "MyClass" n'a pas pu être trouvée (vous manque une directive using ou une référence d'assembly?

Je sais qu'en Java, j'ai déconner avec CLASSPATH pour obtenir ce genre de choses à travailler, mais je n'ai aucune idée sur le C#.

Détails supplémentaires:

Comme vous l'avez sans doute deviné, je suis la compilation et l'exécution via l'invite de commande. Je suis de la compilation de mon non-classe principale à l'aide de /target:library (j'ai entendu dire que seules les principales classes .les fichiers exe).

Mon code ressemble à ceci:

public class MyClass {
    void stuff() {

    }
}

et ma classe principale:

using System;
using MyClass;

public class MyMainClass {
    static void Main() {
        MyClass test = new MyClass();
        /* Doesn't work */
    }
}

J'ai essayé d'englober mon non-classe principale avec namespace MyNamespace { } et de l'importation, mais ça ne fonctionne pas non plus.

Vous faire passer à la bibliothèque générée en entrée par le compilateur lors de la compilation de la classe principale, à droite? Aussi, vous devriez être en mesure de passer les deux fichiers ensemble pour le compilateur - pas besoin d'une bibliothèque ici.
Avez-vous ajouté l'autre fichier (celui où MyClass) de la solution dans Visual studio?
Quelle est la solution? Ce que visual studio? Je ne suis pas en utilisant un IDE, je suis en utilisant l'invite de commande.
Comment dois-je faire? 😮
Pourquoi avez-vous compilez à partir de la ligne de commande? La première classe est compilé dans un fichier DLL. Lorsque vous compilez le deuxième assemblée (avec MyMainClass), vous devrez faire référence à la première assemblée. Si vous êtes à l'aide de C# fichiers de Projet (*.csproj) à partir de Visual Studio, cliquez droit sur "Références", "Ajouter une Référence...", et le point de la DLL à partir de votre première compilation. Si vous n'utilisez pas csproj-fichiers, utiliser les /r option du compilateur.

OriginalL'auteur Bluefire | 2013-02-06

c#class main

24

using est pour les espaces de noms seulement - si les deux classes sont dans le même espace de noms il suffit de déposer la using.

Vous avez fait référence à l'assembly créé dans la première étape lorsque vous compilez le .exe:
```
csc /t:library /out:MyClass.dll MyClass.cs
csc /reference:MyClass.dll /t:exe /out:MyProgram.exe MyMainClass.cs
```
Vous pouvez rendre les choses plus simples, si vous venez de compiler les fichiers ensemble:
```
csc /t:exe /out:MyProgram.exe MyMainClass.cs MyClass.cs
```
ou
```
csc /t:exe /out:MyProgram.exe *.cs
```
MODIFIER:
Voici comment les fichiers devrait ressembler à:

MyClass.cs:
```
namespace MyNamespace {
    public class MyClass {
        void stuff() {

        }
    }
}
```
MyMainClass.cs:
```
using System;

namespace MyNamespace {
    public class MyMainClass {
        static void Main() {
            MyClass test = new MyClass();
        }
    }
}
```
Mais quand j'ai les deux dans le même espace de noms, il me donne exactement la même erreur quand j'essaie de l'utiliser.
Post de la ligne de commande que vous utilisez pour compiler, et le contenu des fichiers, y compris les espaces de noms.
Meilleure réponse, car il donne en fait les lignes de commande pour la compilation. Affiche originale devra décider s'il veut que les classes de deux assemblées distinctes (compiler une classe à la bibliothèque (DLL), puis de la compilation de la deuxième classe à l'exécutable avec référence à la DLL de la première compilation) ou en une seule assemblée (compiler une fois avec les deux fichiers). C'est quelque chose de beaucoup de gens à gérer par avoir des "projets" à l'intérieur de Visual Studio lorsque les projets font référence les uns aux autres (non circulaire) et chaque projet contient un ou plusieurs fichiers de code.

OriginalL'auteur Alex
12

Je sais que c'est une très vieille question, mais j'ai eu la même exigence et découvert juste après c#6, vous pouvez utiliser l'électricité statique dans l'aide pour les classes à importer.

J'espère que cela aide quelqu'un....
```
using static yourNameSpace.YourClass;
```
Clair et précis, +1.

OriginalL'auteur Jack Gajanan

Bien ce que vous avez à "importer" (utilisation) est l'espace de noms de MyClass pas le nom de la classe elle-même. Si les deux classes sont dans le même espace de noms, vous n'avez pas à "importer".

Définition MyClass.cs

namespace Ns1
{
    public class MyClass
    {
        ...
    }
}

Utilisation AnotherClass.cs

using Ns1;

namespace AnotherNs
{
    public class AnotherClass
    {
        public AnotherClass()
        {
            var myInst = new MyClass();
        }
    }
}

OriginalL'auteur DHN

1

Si l'autre classe est compilée comme une bibliothèque (c'est à dire une dll) et c'est de cette manière que vous la voulez, vous devez ajouter une référence à partir de visual studio, de parcourir et de pointer vers le fichier dll.

Si ce que vous voulez est d'intégrer l'OtherClassFile.cs dans votre projet, et de l'espace de noms est déjà identique, vous pouvez:
1. Fermez votre solution
2. Ouvrir YourProjectName.csproj fichier, et de regarder pour cette section:
```
<ItemGroup>                                            
    <Compile Include="ExistingClass1.cs" />                     
    <Compile Include="ExistingClass2.cs" />                                 
    ...
    <Compile Include="Properties\AssemblyInfo.cs" />     
</ItemGroup>
```
1. Vérifier que l' .cs fichier que vous souhaitez ajouter est dans le dossier du projet (même dossier que toutes les classes existantes dans la solution).
2. Ajouter une entrée à l'intérieur comme ci-dessous, enregistrez et ouvrez le projet.
```
<Compile Include="OtherClassFile.cs" /> 
```
Votre classe, va maintenant apparaître et de se comporter dans le cadre du projet. Aucune aide n'est nécessaire. Cela peut être fait de plusieurs fichiers en un seul coup.

OriginalL'auteur Guy
0

MyClass est un classe pas un espace de noms. Si ce code est faux:
```
using MyClass //THIS CODE IS NOT CORRECT
```
Vous devriez vérifier l'espace de noms de la MyClass (e.g: MyNamespace). Ensuite l'appeler d'une manière appropriée:
```
MyNamespace.MyClass myClass =new MyNamespace.MyClass();
```
OriginalL'auteur Hossein Narimani Rad

using est utilisée pour importer les espaces de noms et non des classes.

Donc, si votre classe est dans l'espace de noms X

namespace X
{
    public class MyClass {
         void stuff() {

         }
    }
}

puis de l'utiliser dans un autre espace de noms où vous le souhaitez

using System;
using X;

public class MyMainClass {
    static void Main() {
        MyClass test = new MyClass();
    }
}

OriginalL'auteur gzaxx

0

Si elles sont séparées des fichiers de classe au sein du même projet, vous n'avez pas besoin d'avoir un 'importer' instruction. Suffit d'utiliser la classe tout de suite. Si les fichiers sont dans des projets distincts, vous devez ajouter une référence au projet d'abord avant de vous pouvez utiliser un "importer" déclaration sur elle.

OriginalL'auteur RobStevo
0
```
namespace MyNamespace
{
    public class MyMainClass
    {
        static void Main()
        {
            MyClass test = new MyClass();
        }
    }

    public class MyClass
    {
        void Stuff()
        {

        }
    }
}
```
Vous n'avez pas besoin d'utiliser un espace de noms de l'époque parce qu'il est tout encompased dans le même espace de noms.

Si vous n'êtes pas sûr de ce que votre espace de noms de la classe est situé, le type de la classe (sensible à la casse que vous souhaitez utiliser) puis avec le curseur de votre souris sur la classe, l'utilisation CTRL + . et il vous offre une importation manuelle.

OriginalL'auteur LukeHennerley
-1

La seule chose que vous pouvez faire est de mettre les deux dans le même espace de noms. Ensuite , vous n'avez pas besoin de l'importer. Vous pouvez directement y accéder.
```
using System;
namespace MyNamespace
{
    public class SampleClass1
    {
        //Can access SampleClass2 here
    }
}


using System;
namespace MyNamespace
{
    public class SampleClass2
    {
        //Can access SampleClass1 here
    }
}

using System;
namespace MyNamespace
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            //Can access both of above classes
        }
    }
}
```
Vous: La seule chose que vous pouvez faire est de mettre les deux dans le même espace de noms. Incorrecte. Types différents espaces de noms peuvent se référer les uns des autres. Ce n'est pas vraiment sur les espaces de noms, c'est sur la compilation de plusieurs fichiers de code à partir de la ligne de commande. Aussi, le concept des espaces de noms est orthogonal à l'concepts de projets/modules/assemblées.
Désolé pour cette stupide erreur de ma...mais la question a été édité après ma réponse. Auparavant, il était sur l'utilisation de l'autre classe dans la méthode principale et le demandeur a été l'importation de la classe, c'était donc la réponse correcte à cette époque..Vous pouvez modifier ma réponse si mal au contexte actuel..Merci monsieur pour orthogonale concept..!!

OriginalL'auteur Bhushan Firake

Vous devez vous connecter pour publier un commentaire.