项目开发中命名空间/程序集的使用及跨程序共享类方法问询

Hey there! Let's break down how namespaces and assemblies work together to share classes across projects, plus answer your specific questions about accessing classes from other programs.

Let's get the basics straight because mixing these up is super common:

• Namespaces: They're logical containers for organizing classes to avoid naming conflicts. Think of them like folders for your code—they group related types together, but they don't hold any actual code themselves.
• Assemblies: These are physical files (usually .dll or .exe) that contain the compiled binary code of your classes, along with metadata. They're the actual "packages" that carry your code from one project to another.

To share classes, you need both: namespaces keep your code organized, and assemblies let you move that code between projects.

Here's how to set up class sharing in a typical .NET project workflow:

• Step 1: Create a Class Library (Assembly)
  Make a new Class Library project (this generates a .dll assembly). Inside it, define your shared class with a clear namespace:

  namespace SharedBusinessLogic
  {
      // Mark the class public so it's accessible outside the assembly
      public class OrderProcessor
      {
          public void ProcessOrder(int orderId)
          {
              // Logic here
          }
      }
  }
  

• Step 2: Reference the Assembly in Your Target Project
  In the project where you want to use the shared class, add a reference to the .dll (or the class library project itself, if they're in the same solution). For example:
  • In Visual Studio: Right-click your project → Add → Reference → Select the class library project or browse to the .dll file.
• Step 3: Use the Namespace to Access the Class
  At the top of your code file, import the namespace with a using directive, then use the class like any other:

  using SharedBusinessLogic;
  
  public class OrderService
  {
      public void HandleOrder(int id)
      {
          var processor = new OrderProcessor();
          processor.ProcessOrder(id);
      }
  }
  

Short answer: No. Namespaces are just logical labels—they don't contain any executable code. To access a class from another program, you must reference its assembly first.

Here are the two main ways to do this:

Option 1: Static Assembly Reference (Compile-Time) #

This is the most common approach for projects you control:

1. Get the assembly file (.dll or .exe) from the other program. Note: Even .exe files are valid assemblies you can reference.
2. Add the assembly reference to your project (same as Step 2 above).
3. Import the namespace with using [NamespaceName]; and use the class directly:

   using ExternalApp.DataModels;
   
   var user = new UserModel(); // UserModel is from the external assembly
   

Option 2: Dynamic Assembly Loading (Run-Time) #

If you can't reference the assembly at compile time (e.g., you need to load plugins), use .NET's reflection to load the assembly on the fly:

using System.Reflection;

// Load the external assembly from a file path
Assembly externalAssembly = Assembly.LoadFrom(@"C:\Apps\ExternalApp.exe");

// Get the type using its full namespace + class name
Type userType = externalAssembly.GetType("ExternalApp.DataModels.UserModel");

// Create an instance of the class
object userInstance = Activator.CreateInstance(userType);

// Call a method on the instance (e.g., a method called "SetName")
MethodInfo setNameMethod = userType.GetMethod("SetName");
setNameMethod.Invoke(userInstance, new object[] { "Alice" });

• Pro tips: Ensure the external class is public, and double-check the full type name (namespace + class name). For .NET Core/.NET 5+, you might need to handle dependency resolution if the external assembly has its own references.

• ❌ "Namespaces are all you need to access external classes": Nope—without the assembly, the CLR has no idea where to find the actual code for the class.
• ❌ "One assembly = one namespace": Wrong. A single assembly can have multiple namespaces, and a single namespace can span multiple assemblies (e.g., the System namespace is split across dozens of .NET core assemblies).

内容的提问来源于stack exchange，提问作者Josh Wheeler