web-dev-qa-db-fra.com

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

Je suis assez nouveau en C # et j'ai créé une classe que j'aimerais utiliser dans ma classe principale. Ces deux classes sont dans des fichiers différents, mais lorsque j'essaie d'importer l'une dans l'autre avec using, cmd dit:

Le type ou le nom de l'espace de noms "MyClass" est introuvable (manque-t-il une directive using ou une référence d'assembly?

Je sais qu'en Java je dois jouer avec CLASSPATH pour que des choses comme ça fonctionnent, mais je n'ai aucune idée de C #.

Détails supplémentaires:

Comme vous l'avez probablement compris, je compile et exécute via l'invite de commande. Je compile ma classe non principale en utilisant /target:library (J'ai entendu dire que seules les classes principales devraient être des 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 ma classe non principale avec namespace MyNamespace { } et l'importer, mais cela ne fonctionne pas non plus.

c#classmain
17
Bluefire

using est destiné aux espaces de noms uniquement - si les deux classes sont dans le même espace de noms, il suffit de supprimer le using.

Vous devez référencer l'assembly créé à 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 simplifier les choses en compilant simplement les fichiers ensemble:

csc /t:exe /out:MyProgram.exe MyMainClass.cs MyClass.cs

ou

csc /t:exe /out:MyProgram.exe *.cs

MODIFIER : voici à quoi devraient ressembler les fichiers:

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();
        }
    }
}
26
Alex

Je sais que c'est une très vieille question, mais j'avais la même exigence et je viens de découvrir qu'après c # 6, vous pouvez utiliser la statique pour utiliser les classes à importer.

J'espère que ça aidera quelqu'un....

using static yourNameSpace.YourClass;
16
Jack Gajanan

Eh bien, ce que vous devez "importer" (utiliser), c'est l'espace de noms de MyClass pas le nom de la classe lui-même. Si les deux classes sont dans le même espace de noms, vous n'avez pas à "l'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();
        }
    }
}
3
DHN

Si l'autre classe est compilée en tant que bibliothèque (c'est-à-dire une DLL) et que vous le souhaitez, vous devez ajouter une référence de Visual Studio, parcourir et pointer vers le fichier DLL.

Si vous voulez incorporer OtherClassFile.cs dans votre projet et que l'espace de noms est déjà identique, vous pouvez:

  1. Fermez votre solution,

  2. Ouvrez le fichier YourProjectName.csproj et recherchez cette section:

    <ItemGroup>                                            
    <Compile Include="ExistingClass1.cs" />                     
    <Compile Include="ExistingClass2.cs" />                                 
    ...
    <Compile Include="Properties\AssemblyInfo.cs" />     
</ItemGroup>

  1. Vérifiez que le fichier .cs que vous souhaitez ajouter se trouve dans le dossier du projet (même dossier que toutes les classes existantes de la solution).

  2. Ajoutez une entrée à l'intérieur comme ci-dessous, enregistrez et ouvrez le projet.

    <Compile Include="OtherClassFile.cs" />

Votre classe apparaîtra et se comportera désormais dans le cadre du projet. Aucune utilisation n'est nécessaire. Cela peut être fait plusieurs fichiers en une seule fois.

1
Guy
namespace MyNamespace
{
    public class MyMainClass
    {
        static void Main()
        {
            MyClass test = new MyClass();
        }
    }

    public class MyClass
    {
        void Stuff()
        {

        }
    }
}

Vous n'avez alors pas besoin d'utiliser un espace de noms car il est tout compris dans le même espace de noms.

Si vous n'êtes pas sûr de quel espace de noms se trouve votre classe, tapez la classe (sensible à la casse que vous souhaitez utiliser) puis avec votre curseur sur la classe, utilisez CTRL + . et il vous proposera une importation manuelle.

0
LukeHennerley

MyClass est un classe pas un namespace. Donc, ce code est faux:

using MyClass //THIS CODE IS NOT CORRECT

Vous devez vérifier l'espace de noms de MyClass (par exemple: MyNamespace). Ensuite, appelez-le correctement:

MyNamespace.MyClass myClass =new MyNamespace.MyClass();
0
Hossein Narimani Rad

using est utilisé pour importer des 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();
    }
}
0
gzaxx

S'il s'agit de fichiers de classe distincts dans le même projet, vous n'avez pas besoin d'avoir une instruction "import". Utilisez tout de suite le cours. Si les fichiers se trouvent dans des projets distincts, vous devez d'abord ajouter une référence au projet avant de pouvoir utiliser une instruction 'import' dessus.

0
RobStevo