面向对象—在线文件管理模块

面向对象—在线文件管理模块

2012-08-21 21:42 by xiangxiong, 527 阅读, 3 评论, 收藏, 编辑

在园子里看到好多关于在线文件管理系统的文章和源代码，大家实际上达到的目的其实多大同小异，但是采用的实现的方式大有不同。

本人刚好在项目中应用到在线文件管理模块，如实自己开始写了一个Demo,当然也参考了网上高人写的代码，下面介绍我对这个模块实现的思路和实现。

 

实现思路介绍：

文件对象        FileSystemItem.cs

文件操作管理类  FileSystemManager.cs

界面            Demo.aspx

Js              jqModal.js   弹出窗口

 

文件对象

此类对文件对象的属性进行封装。

 using System;

using System.Collections.Generic;
using System.Text;

namespace FileManager
{
    /// <summary>
    /// FileSystemItem
    /// </summary>
    public class FileSystemItem
    {
        private string _Name;
        private string _FullName;

        private DateTime _CreationDate;
        private DateTime _LastAccessDate;
        private DateTime _LastWriteDate;

        private bool _IsFolder;

        private long _Size;
        private long _FileCount;
        private long _SubFolderCount;

        private string _Version;

        /// <summary>
        /// 名称
        /// </summary>
        public string Name
        {
            get
            {
                return _Name;
            }
            set
            {
                _Name = value;
            }
        }

        /// <summary>
        /// 完整目录
        /// </summary>
        public string FullName
        {
            get
            {
                return _FullName;
            }
            set
            {
                _FullName = value;
            }
        }

        /// <summary>
        /// 创建时间
        /// </summary>
        public DateTime CreationDate
        {
            get
            {
                return _CreationDate;
            }
            set
            {
                _CreationDate = value;
            }
        }

        /// <summary>
        /// 是否是文件夹
        /// </summary>
        public bool IsFolder
        {
            get
            {
                return _IsFolder;
            }
            set
            {
                _IsFolder = value;
            }
        }

        /// <summary>
        /// 大小
        /// </summary>
        public long Size
        {
            get
            {
                return _Size;
            }
            set
            {
                _Size = value;
            }
        }

        /// <summary>
        /// 访问时间
        /// </summary>
        public DateTime LastAccessDate
        {
            get
            {
                return _LastAccessDate;
            }
            set
            {
                _LastAccessDate = value;
            }
        }

        /// <summary>
        /// 修改时间
        /// </summary>
        public DateTime LastWriteDate
        {
            get
            {
                return _LastWriteDate;
            }
            set
            {
                _LastWriteDate = value;
            }
        }

        /// <summary>
        /// 文件数
        /// </summary>
        public long FileCount
        {
            get
            {
                return _FileCount;
            }
            set
            {
                _FileCount = value;
            }
        }

        /// <summary>
        /// 文件夹数
        /// </summary>
        public long SubFolderCount
        {
            get
            {
                return _SubFolderCount;
            }
            set
            {
                _SubFolderCount = value;
            }
        }

        /// <summary>
        /// 版本
        /// </summary>
        /// <returns></returns>
        public string Version()
        {
            if (_Version == null)
                _Version = GetType().Assembly.GetName().Version.ToString();

            return _Version;
        }

    }
}

文件操作类

此类封装对文件的,新建，重命名，删除，复制，剪贴，上传等操作。

 using System;

using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Web;

namespace FileManager
{
    /// <summary>
    /// FileSystemManager
    /// </summary>
    public class FileSystemManager
    {
        private static string strRootFolder;

        static FileSystemManager()
        {
            strRootFolder = HttpContext.Current.Request.PhysicalApplicationPath;
            strRootFolder = strRootFolder.Substring(0, strRootFolder.LastIndexOf(@"\"));
        }

        /// <summary>
        /// 读根目录
        /// </summary>
        /// <returns></returns>
        public static string GetRootPath()
        {
            return strRootFolder;
        }

        /// <summary>
        /// 写根目录
        /// </summary>
        /// <param name="path"></param>
        public static void SetRootPath(string path)
        {
            strRootFolder = path;
        }

        /// <summary>
        /// 读取列表
        /// </summary>
        /// <returns></returns>
        public static List<FileSystemItem> GetItems()
        {
            return GetItems(strRootFolder);
        }

        /// <summary>
        /// 读取列表
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static List<FileSystemItem> GetItems(string path)
        {
            string[] folders = Directory.GetDirectories(path);
            string[] files = Directory.GetFiles(path);
            List<FileSystemItem> list = new List<FileSystemItem>();
            foreach (string s in folders)
            {
                FileSystemItem item = new FileSystemItem();
                DirectoryInfo di = new DirectoryInfo(s);
                item.Name = di.Name;
                item.FullName = di.FullName;
                item.CreationDate = di.CreationTime;
                item.IsFolder = true;
                list.Add(item);
            }
            foreach (string s in files)
            {
                FileSystemItem item = new FileSystemItem();
                FileInfo fi = new FileInfo(s);
                item.Name = fi.Name;
                item.FullName = fi.FullName;
                item.CreationDate = fi.CreationTime;
                item.IsFolder = true;
                item.Size = fi.Length;
                list.Add(item);
            }

            if (path.ToLower() != strRootFolder.ToLower())
            {
                FileSystemItem topitem = new FileSystemItem();
                DirectoryInfo topdi = new DirectoryInfo(path).Parent;
                topitem.Name = "[上一级]";
                topitem.FullName = topdi.FullName;
                list.Insert(0, topitem);

                FileSystemItem rootitem = new FileSystemItem();
                DirectoryInfo rootdi = new DirectoryInfo(strRootFolder);
                rootitem.Name = "[根目录]";
                rootitem.FullName = rootdi.FullName;
                list.Insert(0, rootitem);

            }
            return list;
        }

        /// <summary>
        /// 读取文件夹
        /// </summary>
        /// <param name="name"></param>
        /// <param name="parentName"></param>
        public static void CreateFolder(string name, string parentName)
        {
            DirectoryInfo di = new DirectoryInfo(parentName);
            di.CreateSubdirectory(name);
        }

        /// <summary>
        /// 删除文件夹
        /// </summary>
        /// <param name="path"></param>
        public static void DeleteFolder(string path)
        {
            Directory.Delete(path);
        }

        /// <summary>
        /// 移动文件夹
        /// </summary>
        /// <param name="oldPath"></param>
        /// <param name="newPath"></param>
        public static void MoveFolder(string oldPath, string newPath)
        {
            Directory.Move(oldPath, newPath);
        }

        /// <summary>
        /// 创建文件
        /// </summary>
        /// <param name="filename"></param>
        /// <param name="path"></param>
        public static void CreateFile(string filename, string path)
        {
            FileStream fs = File.Create(path + "\\" + filename);
            fs.Close();
        }

        /// <summary>
        /// 创建文件
        /// </summary>
        /// <param name="filename"></param>
        /// <param name="path"></param>
        /// <param name="contents"></param>
        public static void CreateFile(string filename, string path, byte[] contents)
        {
            FileStream fs = File.Create(path + "\\" + filename);
            fs.Write(contents, 0, contents.Length);
            fs.Close();
        }

        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="path"></param>
        public static void DeleteFile(string path)
        {
            File.Delete(path);
        }

        /// <summary>
        /// 移动文件
        /// </summary>
        /// <param name="oldPath"></param>
        /// <param name="newPath"></param>
        public static void MoveFile(string oldPath, string newPath)
        {
            File.Move(oldPath, newPath);
        }

        /// <summary>
        /// 读取文件信息
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static FileSystemItem GetItemInfo(string path)
        {
            FileSystemItem item = new FileSystemItem();
            if (Directory.Exists(path))
            {
                DirectoryInfo di = new DirectoryInfo(path);
                item.Name = di.Name;
                item.FullName = di.FullName;
                item.CreationDate = di.CreationTime;
                item.IsFolder = true;
                item.LastAccessDate = di.LastAccessTime;
                item.LastWriteDate = di.LastWriteTime;
                item.FileCount = di.GetFiles().Length;
                item.SubFolderCount = di.GetDirectories().Length;
            }
            else
            {
                FileInfo fi = new FileInfo(path);
                item.Name = fi.Name;
                item.FullName = fi.FullName;
                item.CreationDate = fi.CreationTime;
                item.LastAccessDate = fi.LastAccessTime;
                item.LastWriteDate = fi.LastWriteTime;
                item.IsFolder = false;
                item.Size = fi.Length;
            }
            return item;
        }

        /// <summary>
        /// 复制文件夹
        /// </summary>
        /// <param name="source"></param>
        /// <param name="destination"></param>
        public static void CopyFolder(string source, string destination)
        {
            String[] files;
            if (destination[destination.Length - 1] != Path.DirectorySeparatorChar)
                destination += Path.DirectorySeparatorChar;
            if (!Directory.Exists(destination)) Directory.CreateDirectory(destination);
            files = Directory.GetFileSystemEntries(source);
            foreach (string element in files)
            {
                if (Directory.Exists(element))

                    CopyFolder(element, destination + Path.GetFileName(element));
                else
                    File.Copy(element, destination + Path.GetFileName(element), true);
            }
        }
    }
}

界面：

      

总结：

本人虽然从事软件开发实1年多，但是对面向对象的理解还是不太透彻，也许可能实战还不够经验不足，希望和园友一起探讨和交流,提出宝贵建议和意见。

本人QQ:541719273  （向雄）

 

    /Files/binb/webfilemanager.zip   文件管理模块源代码下载

 

分类: 面向对象编程

标签: 在线文件管理模块

使用ICE建立C++与C#的通讯

    ICE的优势是作为通讯中间件可支持跨平台的通讯，目前支持C++、C#、JAVA、Python、Ruby等多种语言。下面通过一个示例，描述怎样通过ICE建立C++与C#之间的通讯。

一 示例描述

    搭建一个简单的聊天室，服务端使用C++实现，客户端使用C#实现，中间以ICE构建通讯通道。聊天室实现的功能包括：用户登录/注销、发送消息、接受消息。

二 准备Slice文件

    Slice作为ICE本身特有的语言，成为跨平台通讯的桥梁。通过Slice文件描述需要实现的接口，再由ICE提供的各个语言编译器生成各语言的接口类，各语言分别负责根据接口类实现属于本身的逻辑细节即可，据说这种思想是从老牌的通讯中间件CORBA中借鉴过来的。

    聊天室的Slice文件定义如下：

module Chat {

interface Room {

    bool login(string user, MessageReceiver* receiver);

    void logout(string user);

    void sendMessage(string user, string message);

};

interface MessageReceiver {

    void onMessage(string sender, string msg);

};

dictionary<string, MessageReceiver*> UserList;

};

 

   分析上面的Slice文件如下：

1、 在命名空间为Chat下定义了两个类（接口），Room和MessageReceiver。

2、 Room主要是Server端实现，Client端调用。实现了登录、注销和发送信息的接口函数。

3、 MessageReceiver主要是Client端实现，Server端调用的回调函数接口。这是因为Server端在向Client端发送信息的时候，必须知道Client端的通讯地址。因此需要这个回调函数类。

4、 UserList主要是Server端用来存储Client端的用户名及回调函数句柄的。

三 实现Server端

    通过Slice2Cpp程序将Slice文件生成ChatRoom.h和ChatRoom.cpp，将两个文件加入到工程中，同时新建一个类继承Chat::Room，实现Room的三个虚拟函数接口，这个类被称为Server端的Servant类。代码如下：

      

class ChatRoomI :public Chat::Room

       {

       public:

              ChatRoomI(void);

              ~ChatRoomI(void);

              virtual bool login(const ::std::string&, const ::Chat::MessageReceiverPrx&, const ::Ice::Current& );

               virtual void logout(const ::std::string&, const ::Ice::Current& );

              virtual void sendMessage(const ::std::string&, const ::std::string&, const ::Ice::Current&);

       private :

              Chat::UserList _userList;

              void BroadCast(const ::std::string user,const ::std::string message);

              bool Notify(const ::std::string& user, const ::std::string& message, const ::Chat::MessageReceiverPrx& receiver);

 

       };

 

    注意有两个私有函数BroadCast和Notify为从Server端广播消息至Client端时用到的，并没有什么神秘的地方。示例工程可在文章末尾处下载，具体实现细节略去。

四 实现Client端

    使用Slice2CS程序将Slice文件生成ChatRoom.cs文件，将此cs文件添加到一个控制台程序的工程中。新建MsgReceiver类继承Chat.MessageReceiverDisp_,Chat.MessageReceiverOperations_两个抽象类，实现onMessage函数。

public override void onMessage(string sender, string msg, Ice.Current current__)

    {

        Console.WriteLine(String.Format("{0}:{1}", sender, msg));

     }

 

新建Client类，实现Client端与Server端之间的通讯逻辑，并生成MsgReceiver类的本地代理类，发送到Server端实现发送消息的回调逻辑。

            Ice.ObjectAdapter objAdapter =  communicator().createObjectAdapterWithEndpoints(

                "Chat.UserAdapter", "default -h 127.0.0.1 -p 10001");

            Ice.Object msgRece = new MsgReceiver();

            objAdapter.add(msgRece,communicator().stringToIdentity("Chat.User"));

            objAdapter.activate();

 

             Chat.MessageReceiverPrx userPrx = Chat.MessageReceiverPrxHelper.uncheckedCast

(objAdapter.createProxy(communicator().stringToIdentity("Chat.User")));

 

示例工程在本文末尾下载。

 

四 示例截图

Server端：

 

Client端：

 

 代码下载：

Server

Client

 

 

 

 

 

分类: C++