c# 2.0 是否支持将一个类的代码保存在多个文件？

[xiaollx]

如题。

[Macosx]

绝对支持 partial classy就是用来达到这个目的的

It is possible to split the definition of a class or a struct, or an interface over two or more source files. Each source file contains a section of the class definition, and all parts are combined when the application is compiled. There are several situations when splitting a class definition is desirable:

When working on large projects, spreading a class over separate files allows multiple programmers to work on it simultaneously.

When working with automatically generated source, code can be added to the class without having to recreate the source file. Visual Studio uses this approach when creating Windows Forms, Web Service wrapper code, and so on. You can create code that uses these classes without having to edit the file created by Visual Studio.

To split a class definition, use the partial keyword modifier, as shown below:

C# Copy Code
public partial class Employee
{
public void DoWork()
{
}
}

public partial class Employee
{
public void GoToLunch()
{
}
}



Remarks
Using the partial keyword indicates that other parts of the class, struct, or interface can be defined within the namespace. All the parts must use the partial keyword. All of the parts must be available at compile time to form the final type. All the parts must have the same accessibility, such as public, private, and so on.

If any of the parts are declared abstract, then the entire type is considered abstract. If any of the parts are declared sealed, then the entire type is considered sealed. If any of the parts declare a base type, then the entire type inherits that class.

All of the parts that specify a base class must agree, but parts that omit a base class still inherit the base type. Parts can specify different base interfaces, and the final type implements all of the interfaces listed by all of the partial declarations. Any class, struct, or interface members declared in a partial definition are available to all of the other parts. The final type is the combination of all the parts at compile time.

Note
The partial modifier is not available on delegate or enumeration declarations.


Nested types can be partial, even if the type they are nested within is not partial itself. For example:

C# Copy Code
class Container
{
partial class Nested
{
void Test() { }
}
partial class Nested
{
void Test2() { }
}
}



At compile time, attributes of partial-type definitions are merged. For example, the following declarations:

C# Copy Code
[System.SerializableAttribute]
partial class Moon { }

[System.ObsoleteAttribute]
partial class Moon { }



are equivalent to:

C# Copy Code
[System.SerializableAttribute]
[System.ObsoleteAttribute]
class Moon { }



The following are merged together from all the partial-type definitions:

XML comments

interfaces

generic-type parameter attributes

class attributes

members

For example, the following declarations:

C# Copy Code
partial class Earth : Planet, IRotate { }
partial class Earth : IRevolve { }



are equivalent to:

C# Copy Code
class Earth : Planet, IRotate, IRevolve { }



Restrictions
There are several rules to follow when working with partial class definitions:

All partial-type definitions meant to be parts of the same type must be modified with partial. For example, the following class declarations generate an error:

C# Copy Code
public partial class A { }
//public class A { } // Error, must also be marked partial



The partial modifier can only appear immediately before the keywords class, struct, or interface.

Nested partial types are allowed in partial-type definitions, for example:

C# Copy Code
partial class ClassWithNestedClass
{
partial class NestedClass { }
}

partial class ClassWithNestedClass
{
partial class NestedClass { }
}



All partial-type definitions meant to be parts of the same type must be defined in the same assembly and the same module (.exe or .dll file). Partial definitions cannot span multiple modules.

The class name and generic-type parameters must match on all partial-type definitions. Generic types can be partial. Each partial declaration must use the same parameter names in the same order.

The following keywords on a partial-type definition are optional, but if present on one partial-type definition, cannot conflict with the keywords specified on another partial definition for the same type:

public

private

protected

internal

abstract

sealed

base class

new modifier (nested parts)

generic constraints (For more information, see Constraints on Type Parameters (C# Programming Guide).)

Example 1
In the following example, the fields and the constructor of the class, CoOrds, are declared in one partial class definition, while the member, PrintCoOrds, is declared in another partial class definition.

C# Copy Code
public partial class CoOrds
{
private int x;
private int y;

public CoOrds(int x, int y)
{
this.x = x;
this.y = y;
}
}

public partial class CoOrds
{
public void PrintCoOrds()
{
System.Console.WriteLine("CoOrds: {0},{1}", x, y);
}

}

class TestCoOrds
{
static void Main()
{
CoOrds myCoOrds = new CoOrds(10, 15);
myCoOrds.PrintCoOrds();
}
}



Output
CoOrds: 10,15

Example 2
The following example shows that you can also develop partial structs and interfaces.

C# Copy Code
partial interface ITest
{
void Interface_Test();
}

partial interface ITest
{
void Interface_Test2();
}

partial struct S1
{
void Struct_Test() { }
}

partial struct S1
{
void Struct_Test2() { }
}



C# Language Specification
For more information, see the following sections in the C# Language Specification:

23 Partial Types

[xhncmec]

支持，参考partial

[ChrisAK]

嗯..支持.

[mmcl]

可以的
vs2005就已经默认使用了。

[steven262]

当然可以了，这是C#2.0的5个新性之一呀！