通过 WCF 实现点对点文件共享 z

客户端应用配置文件：

<configuration>
<system.serviceModel>
<client>
<endpoint address="http://localhost:8080/QuickReturns/Exchange"
binding="basicHttpBinding"
contract="QuickReturns.StockTrading.ExchangeServiceClient. ITradeService">
</endpoint>
</client>
</system.serviceModel>
</configuration>

这两个类很重要，因为它们是一个计算机网络中所有节点之间的连接的基础。在我们建立一个文件共享系统的代码中我们将完全依仗这些类，所以花越多成本来理解这两个类如何工作的，我们就能越多理解如何能在网络节点之间共享文件。你可以阅读我提到的书的第3章来深度理解他们。

你需要知道关于WCF的丰富细节。所以我强烈建议详细学习WCF，否则阅读代码只会徒劳无功。我试着举出一些WCF的重要基础，但你需要至少开发一个从客户机向服务器（运行着一个服务）发出远程调用的项目。在深入研究WCF之前，我有一些严重的问题。最终，我得出的结论是，我需要从头学习WCF，和忘了以前我曾通过 Visual Studio 用它来创建过一些 Web 服务，因为那些印象没有好处。至于其他的，让我们先谈谈点对点对等结构和概念。

点对点的概念

在本节，我将总述P2P架构的主要概念，因为这些介绍对于开发共享文件系统相当重要。

首先，我将要讨论不同类型的P2P网络。有两种不同类型的点对点网络：纯点对点网络和混合型P2P网络。看起来它们的名字已经解释了这两类网络，但我们仍需要明确这两种类型的不同。纯P2P网络是网络中的各个结点通过其它的结点工作，不存在客户端和服务器的区分，每个节点互相关联并一起工作，同时根据需要发挥着客户端和服务器的作用。混合型P2P网络是虽然网络是由客户端和服务器组成的，但服务器仅用于响应由对等结点发出的获取信息的请求的。服务器不会存储除了总数之外的任何数据。例如，在P2P的共享文件系统中，一个节点请求关于其它结点和当前共享文件存储位置的信息，服务器会响应它们的请求，给出共享文件的一些信息如文件大小、结点的名称、文件的扩展名和可用的结点们。在我们讨论P2P网络时，我们遇到了一些表达和概念，它们对于理解P2P网络相当的重要。下面我将解释一些重要的概念，对它们进行总结以便在本文中理解它们。

网格：在点对点应用中的网络称为网格或者网格网络。
结点通道：结点通道是WCF中基于消息的可用的服务。
分组：在对等网中，结点通过复制包含Data.Grouping记录来交换消息。这些记录中的Data.Grouping在WindowsXP SP2系统中是可用的。
网络的类型：有两种类型的网格网络：

结点：网络中的每一台可以一起互相交互的计算机，称为结点。

云：云是一种网格网络，它有一个特定的地址范围，这个地址范围与IPV6范围相关。云中的结点可以通过这个范围进行通信。两种预定义的云，如下：

全球性的云：如果一台计算机接入了互联网，那么它就加入了全球性的云。
本地链接云：一些结点通过广域网互相关联，那么它们就是在一个本地链接云里。

PNRP(*相当重要)：

“当我们在云里时，每个结点都应当通过唯一的编号识别。正如你所知道的，在使用互联网时，我们是通过DNS识别每一台服务器的。但是在网格网络中不能使用DNS，因为结点实际上是动态的。结点原本就是动态的，我们不能使用静态的IP地址。因此我们使用了另一种称作是对等结点命名解决方案的协议（PNRP）而不是DNS协议来解决结点编号的问题。”

结点名称（在.NET 网络中对等结点的主机名）：

每个结点除了它的编号之外会有一个称为“结点名称”。结点名称可以被注册，不论名称是安全的或者不安全的。在私有网中安全的名称是推荐的；也建议在全球网络中使用安全的名称。不安全的网络可以看到以0.开头的结点名称,例如0.Peer1。安全的名称也可以做为数字签名。在.NET网络中你可以通过它的名称确定（解析）一个结点。

结点图表：图表是结点的集合，这些结点可以通过与它们相邻结点的连接与其它的结点通信，因此，使得向图表中的所有结点发送消息成为可能。
注册结点：首先结点需要在云中注册。可以通过编程或者是使用netsh命令在云中注册结点。命令行注册如下所示：
解析结点：我们可以使用.NET和netsh命令来解析结点。当我们在解析结点时，事实上，我们在获取结点的信息例如：结点的名称、结点的IP地址和结点的端口，这样我们就可以利用这些结点工作。

关于NetShell和它关于对等网络的命令的信息，请看这里，这篇文章的信息相当的充分。

命名空间：要使用.NET的类来使用结点，我们需要使用System.ServiceModel和System.Net.PeerToPeer这两个命名空间。

代码概述 (系统是如何工作的)

本项目的代码被分割成了如下5个主要的子项目：

FreeFile.DownloadManager
FreeFiles.TransferEngine.WCFPNRP
FreeFiles.UI.WinForm
FreeFilesServerConsole

让我们讨论下这些部分是如何共同工作的，然后我会详述每个部分。

首先，我应该提到这个项目是基于混合式P2P网络。正如我在开始提到的那样，这意味着我们有一些结点和一个服务器(我们把服务器叫做超级结点)。服务器结点通过存储、准备一些诸如文件路径、结点ID这样的信息，促进结点协作，从而向其它结点提供服务。所以，我们需要一个服务器，执行一些比如(搜索文件)的任务。因此，我们需要搭建一个WCF服务器，让其它结点能够连接上并获得他们需要的信息。服务器可以是Windows服务或者控制台服务器。在本项目中，它是控制台项目，虽然我认为它最好是一个Windows服务。另一个WCF服务应该在结点之间进行连结并下载需要文件的时候运行。因此，我们应该需要在同时运行两个WCF服务。

当我和我的同事决定把这个项目作为开源应用程序时，我们计划让其具有相当的可靠性和灵活性，因此，我们把这个项目分成了几层，并分摊每个任务到单独的一层中。我会讨论DownloadManager类、TransferEngine类和ServerConsole类，这几层的代码。

核心传输引擎层(Core Transfer Engine Layer)

这一层承担了一个结点行为的所有任务，同时也能够在结点间传输需要的文件。在本项目中，我们希望看到一些关于结点的代码。这部分是系统的核心部分。当一个结点开始工作的时候，首先，它应该把自己注册为一个参与结点，然后它应该同时扮演服务器和客户端的角色。然后，如果某个参与结点请求一个文件，首先要搜索这个文件，然后当它收到了这个文件的信息(比如目标结点的主机名)，它应该用那些信息连接到对应的结点然后下载文件。PNRPManager类是用来注册和解析结点用的。

public List<PeerInfo>  Register()
{
    List<PeerInfo>  registerdPeer = new List<PeerInfo>();
    foreach (var registration in registrations)
    {
        string timeStamp = string.Format("FreeFile Peer Created at : {0}", 
          DateTime.Now.ToShortTimeString());
        registration.Comment = timeStamp;
        
            try
            {
                registration.Start();
                if (registerdPeer.FirstOrDefault(x => x.HostName == 
                   registration.PeerName.PeerHostName) == null)
                {
                    PeerInfo peerInfo = new PeerInfo(registration.PeerName.PeerHostName, 
                      registration.PeerName.Classifier, registration.Port);
                    peerInfo.Comment = registration.Comment;
                    registerdPeer.Add(peerInfo);
                }
            }
            catch { }
        
    }
    this.CurrentPOeerRegistrationInfo = registerdPeer;                    
    return registerdPeer;
}

Start()方法注册结点，而Stop()方法注销某个云中的结点。为了获取一个结点的信息，结点会被解析。当一个结点解析完成，一些信息诸如结点主机名(peer host name)，标识符(Classifier)，端口号(port)是可以访问的。ResolveByPeerHostName()方法可以通过主机名解析一个结点并返回一个列表形式的PeerInfo。

public List<PeerInfo> ResolveByPeerHostName(string peerHostName)
{
    try
    {
        if (string.IsNullOrEmpty(peerHostName))
            throw new ArgumentException("Cannot have a null or empty host peer name.");

        PeerNameResolver resolver = new PeerNameResolver();
        List<PeerInfo> foundPeers = new List<PeerInfo>();
        var resolvedName = resolver.Resolve(new PeerName(peerHostName, 
          PeerNameType.Unsecured), Cloud.AllLinkLocal);                
        foreach (var foundItem in resolvedName)
        {
            foreach (var endPointInfo in foundItem.EndPointCollection)
            {
                PeerInfo peerInfo = new PeerInfo(foundItem.PeerName.PeerHostName, 
                  foundItem.PeerName.Classifier,endPointInfo.Port);
                peerInfo.Comment = foundItem.Comment;
                foundPeers.Add(peerInfo);
            }

        }
        return foundPeers;
       
    }
        catch (PeerToPeerException px)
        {
            throw new Exception(px.InnerException.Message);
        }

    }        
}

当解析结束后，得到了一系列结点，以EndPointCollection类的对象的形式出现。如果我们使用foreach循环，我们可以访问其中所有的结点作为终端结点。

FileTransferServiceHost 类使每个点成为向另外的点提供所需文件的服务器主机。这个类使用 TCP 协议在各点间传输数据。DoHost() 方法得到一个基于节点主机名的地址，然后添加一个应用了 ServiceContract 属性的接口。因此每个点都向外部世界发布了一个服务以使其方法可通过服务被访问到。（在这种情况下，方法是 TransferFile 和 TransferFileByHash）

sealed class FileTransferServiceHost
{
    public void DoHost(List<PeerInfo> peers)
    {
        Uri[] Uris = new Uri[peers.Count];

        string Address = string.Empty;
        for (int i = 0; i < peers.Count; i++)
        {
            Address = string.Format("net.tcp://{0}:{1}/TransferEngine", 
              peers[i].HostName, peers[i].Port);
            Uris[i] = new Uri(Address);
        }

        FileTransferServiceClass currentPeerServiceProxy = new FileTransferServiceClass();
        ServiceHost _serviceHost = new ServiceHost(currentPeerServiceProxy, Uris);
        NetTcpBinding tcpBinding = new NetTcpBinding(SecurityMode.None);
        _serviceHost.AddServiceEndpoint(typeof(IFileTransferService), tcpBinding, "");

        _serviceHost.Open();
    }
}

[ServiceContractAttribute]
 interface IFileTransferService
{
    [OperationContractAttribute(IsOneWay = false)]
    byte[] TransferFileByHash(string fileName,string hash, long partNumber);
    
    [OperationContractAttribute(IsOneWay = false)]
    byte[] TransferFile(string fileName, long partNumber);
}

如果一个客户端（点）想要访问到另一个点的方法，应使用Channel（通道）得到这个能力。这一部分已被编码在FileTransferServiceClientClass 类中，如下：

[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Single, 
           InstanceContextMode = InstanceContextMode.Single, UseSynchronizationContext = false)]
class FileTransferServiceClientClass : System.ServiceModel.ClientBase<IFileTransferService>
{
    public FileTransferServiceClientClass() :base()
    {
    }

    public FileTransferServiceClientClass(string endpointConfigurationName) : 
            base(endpointConfigurationName)
    {
    }

    public FileTransferServiceClientClass(string endpointConfigurationName, string remoteAddress) : 
            base(endpointConfigurationName, remoteAddress)
    {
    }

    public FileTransferServiceClientClass(string endpointConfigurationName, 
      System.ServiceModel.EndpointAddress remoteAddress) : 
            base(endpointConfigurationName, remoteAddress)
    {
    }

    public FileTransferServiceClientClass(System.ServiceModel.Channels.Binding binding, 
      System.ServiceModel.EndpointAddress remoteAddress) : 
            base(binding, remoteAddress)
    {
    }

    public byte[] TransferFile(string fileName,string hash, long partNumber)
    {
        return base.Channel.TransferFileByHash(fileName, hash, partNumber);
    }

    public byte[] TransferFile(string fileName, long partNumber)
    {
        return base.Channel.TransferFile(fileName, partNumber);
    }
}

这个应用程序的每个实例把自身登记作为一个节点，然后用 FileTransferServiceHost 开始建立一个 WCF 服务，如下：

void IFileProviderServer.SetupFileServer()
{

    var peers = pnrpManager.Register();
    if (peers == null || peers.Count == 0) throw new Exception("Host not registered!");
    var fileTransferServiceHost = new FileTransferServiceHost();
    fileTransferServiceHost.DoHost(peers);
}

下载管理层

这一层保证了管理下载任务后边的所有活动，例如管理下载处理和异常，下载文件，把请求的文件分片，然后异步的下载各分片，基于哈希编号或者名称检索文件，共享文件夹，并把下载的文件存储到共享文件夹中。

这个search()类提供了搜索的引擎来查找跨服务的目标文件，这些服务运行在服务层。如我前边所讲述的，服务器发布了服务，这些服务提供了应用结点的一些公共的信息（例如文件名、结点主机名，文件类型）。在下边的段落中我将详细的讲述服务层的代码。

public List<Entities.File> Search(string searchPattern)
{
    FileServer.FilesServiceClient fileServiceClient = new FileServer.FilesServiceClient();
    
    List<Entities.File> filesList = new List<File>();
    foreach (var file in fileServiceClient.SearchAvaiableFiles(searchPattern))
    {
        Entities.File currentFile = new File();
        currentFile.FileName = file.FileName;
        currentFile.FileSize = file.FileSize;
        currentFile.FileType = file.FileType;
        currentFile.PeerID = file.PeerID;
        currentFile.PeerHostName = file.PeerHostName;
        filesList.Add(currentFile);
    }
    return filesList;
}

这层代码核心的部分是FileTransferManager类，它管理了文件的传送过程。它由下载全部或部分文件的全部所需的方法构成。UI层调用该类的Download()方法，这个方法启动任务，使用StartDownload方法开始它的动作。随后StartDownload方法被调用。通过这个方法，文件的请求是基于它的端口号，这个端口号是基于一个常量10240生成的。

public void Download(Entities.File fileSearchResult)
{
    //var action =new Action<object>(searchForSameFileBaseOnHash);
    //Task searchForSameFileBaseOnHashTask = new Task(action, fileSearchResult);
    //searchForSameFileBaseOnHashTask.Start();

    var downloadAction = new Action<object>(StartDownload);
    Task downloadActionTask = new Task(downloadAction, fileSearchResult);
    downloadActionTask.Start();
}

const long FilePartSizeInByte = 10240;

private void StartDownload(object state)
{
    Entities.File fileSearchResult = state as Entities.File;
    //We need to apply multiThreading to use multi host to download different part of
    //file concurrently max number of thread could be 5 thread per host in
    //all of the application;
    long partcount = fileSearchResult.FileSize / FilePartSizeInByte;
    long mod = fileSearchResult.FileSize % FilePartSizeInByte;
    if (mod > 0) partcount++;
    downloadFilePart(new DownloadParameter {FileSearchResult=fileSearchResult, 
       Host = fileSearchResult.PeerHostName, Part =  partcount });
}

如你所见，StartDownload方法调用downloadFilePart方法，这个方法调用TransferEngine类的GetFile方法，TransferEngine类是由factory类创建的。

所以，让我们瞥一下这个工厂类。这个类使用 TransferEngine 层的DLL制造所需引擎（如：搜索引擎或传输引擎）的一个新实例。它需要得到一个DLL文件的路径并加载它，然后利用它的方法。由于“两个类不能同时互相引用”这种理性的原因，我们对一个类库使用这种访问。正如你看到的，它使用信道（channels）访问服务器的方法来下载文件。

public sealed class Factory
{
    Factory()
    {
        Assembly transferEngineAssembly = Assembly.LoadFile(String.Format(
          "E:\FreeFiles\FreeFiles.TransferEngine.WCFPNRP\bin\Debug\FreeFiles.TransferEngine.WCFPNRP.dll"));            
        var tnaTypes = transferEngineAssembly.GetTypes();
        foreach (var item in tnaTypes)
        {
            if (item.GetInterface("ITransferEngineFactory") != null)
            {
                ITransferEngineFactory ITransferEngineFactory = Activator.CreateInstance(item) as ITransferEngineFactory;
                this.transferEngine = ITransferEngineFactory.CreateTransferEngine();
                this.fileProviderServer = this.transferEngine as IFileProviderServer;
                break;
            }
        }
        /* Create
         *searchEngine;
        */
        this.searchEngine = new Searchengine();
    }..................................................................

在这个类中，我用一个字串作为 DLL 的路径，但这是错的，会弄出许多问题（例如，对于每个用户，我们必须根据实情重新设置文件路径，这太笨了）。那么，正确的方式是使用一个返回应用程序文件夹路径的方法。

如之前曾提到的，这个层是此项目的一个非常重要的组成部分，有很多可以采用它的衍生物（在未来的版本）。

服务器层

欢迎进入到本文要解释的最后一层。解释服务器这一层，我想说它就是一个WCF服务，它提供了文件(点对点共享的文件)之间检索的一些方法。这一层使用Entity Framework作为统一操作数据库的对象关系映射(ORM)。打开edmx文件，您将看到如下的数据库架构：

基于以上的设计，每一个节点可以关联多个文件(一对多的关系)，这也恰恰是我们所期望的。这个结构非常简单，但是当我们要开发更复杂的系统的时候，它会变得十分精巧(这是本项目后续版本要实现的主要目标)。不管怎样，就像我说的，这一层扮演着WCF服务的角色，这个重要的角色在FilesService类中实现，如下：

public class FilesService
{
    private FreeFilesEntitiesContext _freeFilesObjectContext=new FreeFilesEntitiesContext();
    [OperationContract]
    public void AddFiles(List<Entities.File> FilesList,Entities.Peer peer)
    {
        FileRepository fileRepository = new FileRepository
        (_freeFilesObjectContext as FreeFilesServerConsole.IUnitOfWork);
        this.AddPeer(externalPeerToEFPeer(peer));
        fileRepository.AddFiles(externalFileToEFFile(FilesList));
        
        SaveFile();
    }
    [OperationContract]
    public void AddPeer(FreeFilesServerConsole.EF.Peer Peer)
    {
        FileRepository fileRepository = new FileRepository
        (_freeFilesObjectContext as FreeFilesServerConsole.IUnitOfWork);
        fileRepository.AddPeer(Peer);

    }
    [OperationContract]
    public List<Entities.File> SearchAvaiableFiles(string fileName)
    {
        FileRepository fileRepository = new FileRepository
        (_freeFilesObjectContext as FreeFilesServerConsole.IUnitOfWork);
        return internalFileToEntityFile(fileRepository.SearchAvaiableFiles(fileName));
    }

    public void SaveFile()
    {
        _freeFilesObjectContext.Save();
    }
    .
    .
    .
    .

文件搜索(以及和文件操作相关的其他方法，如添加文件、添加文件所属的节点)的实现在FileRepository类中。

class FileRepository:IFilesRepository
{
    private FreeFilesEntitiesContext _freeFilesObjectContext;
    public FileRepository(IUnitOfWork unitOfWork)
    {
        _freeFilesObjectContext = unitOfWork as FreeFilesEntitiesContext;
    }
    public List<FreeFilesServerConsole.EF.File> SearchAvaiableFiles(string fileName)
    {
        var filesList = from files in _freeFilesObjectContext.Files
                        join peers in _freeFilesObjectContext.Peers on files.PeerID equals peers.PeerID
                        where files.FileName.Contains(fileName)
                        select new {files,peers };
        List<FreeFilesServerConsole.EF.File> List = new List<File>();
        foreach (var item in filesList)
        {
            File file = new File();
            file.FileName = item.files.FileName;
            file.FileSize = item.files.FileSize;
            file.FileType = item.files.FileType;
            file.PeerHostName = item.peers.PeerHostName;
            List.Add(file);
        }
        return List;
    }
 
    public void AddFiles(List<FreeFilesServerConsole.EF.File> FilesList)
    {
        //_freeFilesObjectContext = new FreeFilesEntitiesContext();
        try
        {
            foreach (FreeFilesServerConsole.EF.File file in FilesList)
            {
                _freeFilesObjectContext.Files.AddObject(file);
            }
        }
        catch (Exception exp)
        {
            throw new Exception(exp.InnerException.Message);
        }
    }

    public void AddPeer(FreeFilesServerConsole.EF.Peer Peer)
    {
        //_freeFilesObjectContext = new FreeFilesEntitiesContext();
        try
        {
            _freeFilesObjectContext.Peers.AddObject(Peer);
        }
        catch (Exception exp)
        {
            throw new Exception(exp.InnerException.Message);
        }
    }

    public void Save()
    {
        _freeFilesObjectContext.Save();            
    }
}

正如你所看到的，这个类使用工作单元模式(Unit Of Work)将所有的任务集合到一个任务中。

事实上它有两个重要的优点：在内存中的更新和一次性统一了各种事务处理。更多的细节，建议您阅读这篇文章，我发现它相当的便捷。

另一个应当注意的类是ServiceInitializer.它管理了服务，使得服务对于外部结点而言是通过配置文件的值可以访问的。

public class ServiceInitializer : IServiceInitializer
{
    private string _endPointAddress = string.Empty;
    public ServiceInitializer()
    {
        _endPointAddress = 
          ConfigurationSettings.AppSettings["FileServiceEndPointAddress"].ToString();
    }
    public void InitializeServiceHost()
    {
        Uri[] baseAddresses = new Uri[]{
            new Uri(_endPointAddress),
        };
        ServiceHost Host = new ServiceHost(typeof(FilesService),baseAddresses);

        Host.AddServiceEndpoint(typeof(FilesService),
            new BasicHttpBinding(),"");
        ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
        smb.HttpGetEnabled = true;
        Host.Description.Behaviors.Add(smb);
        Host.Open();
    }
}

在你运行FreeFilesServerConsole项目时这个服务是可用的。你将会看到如下图所示的消息，它发布了WCF服务的开始状态，随后，你可以检索或者共享你所需的文件。

使用代码（如何运行和调试这个应用）

使用这些代码并不像你想像的那样简单，因为你应当在至少两台通过同一网络相互关联的电脑上运行它，如果你认真的阅读了下面的内容，你将可以运行和测试这些代码。

为了运行这个应用，首先，你应当连接到网络并确保防火墙未启用。接着检进你的网络和防火墙。总之，为了运行代码，请参照如下的步骤：

安装附带的数据库或使用VisualStudio服务器端的Generate Database from Edmx file选项，在应用的配置文件FreeFileServerConsole中设定正确的服务器配置。
运行FreeFileServerConsole项目，并等待直到它写完服务运行成功的消息
在网络的两台不同的电脑中打开服务并运行Windows Form application project.
共享文件文件直到它发出完成的Done消息
检索文件，在它找到后，在GridView网络视图中单击文件的名称开始下载。目前还没有显示下载过程的进度条，这个特征将在未来的下一个版本中增加。
需要注意的事：你可以只用一台电脑完成所有这些步骤，但你需要打开两个VisualStudio的实例，然后运行实例中的一个，你需要通过代码修改端口的设置，然后再手动的重新设置，否则在下载文件时，你将会遇到错误。

我想为了成功的运行这个应用再没什么别的细节可以讲述了，除非我遗漏了一些很小的点。如果遇到任务问题，您可以在本文的评论中提出问题。

目前应用是什么样的呢？

首个版本的外观和特征都相当的简单。在你启动应用的各个部分后，就会有一个共享的文件，你可以搜索，并看到网格视图列出的结果。

你可以通过单击共享文件按钮把指定的文件共享。目前共享的样式非常的简洁。在下一个版本中，最大的重要特征之一就是在共享文件夹中批量复制文件，这个些在共享文件夹中的文件其它使用者是可以访问的;或者可以共享文件夹，而不是共享单一的文件。总之，目前这版的外观就是这样的：

此外，当前版本的外观应当更好一些，更加的便利和对终端用户更加的方便。

当前缺点总结

如我前边所说，存在大量的问题和缺失。在一下个版本中可能开发的新的功能点如列表所示，应当关注的是如下要点：

用户友好的界面
端口管理类可以找到当前计算机打开的端口号
高级文件共享处理，例如共享文件夹或者复制文件到一个指定的文件夹（类似Dropbox）
高级搜索功能它由检索文件的哈希代码、相似名称、相关文件等组成。
结点在线或者离线的状态可以供下载文件的用户查看
从共享文件的不同结点下载文件的不同部分。
错误处理：这部分相当的重要，我们将花费大量的时间来把它处理妥当。现在你可以找到大量的空的catch{}代码，这部分至关重要，我们必将尽快的提升这部分。
消息处理
下载状态显示的进度条
根据详细的特征变更数据库的设计
如我所警示的，下载管理层的工厂类，我已经使用了一个string类型做为DLL的路径但它是错误的，它制造了很多的问题，（例如，对每个使用者而言，我们得再次设置文件的路径，这太愚蠢了）。正确的方法是使用一个方法返回应用文件的路径。

在下个版本中有大量潜在的特征应当开发。如果你相信开源开发，参与进来吧！

如何协同开发这个项目

该项目是一个开源项目，因此你可以对它的发展做出贡献。可以说出你的想法和举措来做一个更好和更高级地应用程序，基于目前这个项目的开源本质，可以通过Github来参与开发过程。正如你所知道的，Github是一个基于网页应用程序的开源开发活动。可以与其他开发人员讨论，说出你的想法，跟踪最近的变化，目前bug,给他们说说，关于Github的更多信息，可以参考他们的帮助中心，目前在Github之上应用程序链接是：

•https://github.com/amirjalilifard/FreeFilesProject

你可以下载它，并很容易地对其发展合作。当我提及时，有许多可以开发的想法，好吧，让我们开始吧！

通过 WCF 实现点对点文件共享 z

背景知识

为什么是WCF?

简单介绍一下WCF的历史

基地址(Base Addresses)

Channels