1

13693261870

2022-11-08 110990d2abec1db3c1815419c57cac167013ccef

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
using Npgsql;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.Common;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.AccessControl;
using System.Security.Principal;
using System.Web;
 
namespace ExportMap.cs
{
    public class Tool
    {
        public static readonly string BaseDir = AppDomain.CurrentDomain.BaseDirectory;
 
        public static string FormatBytes(long bytes)
        {
            string[] Suffix = { "Byte", "KB", "MB", "GB", "TB" };
 
            int i = 0;
            double dblSByte = bytes;
            if (bytes > 1024)
                for (i = 0; (bytes / 1024) > 0; i++, bytes /= 1024)
                    dblSByte = bytes / 1024.0;
 
            return String.Format("{0:0.##}{1}", dblSByte, Suffix[i]);
        }
 
        public static string GetUploadFolder()
        {
            return GetFolder("uploadFolder");
        }
 
        public static string GetStyleFolder()
        {
            return GetFolder("styleFolder");
        }
 
        public static string GetDownloadFolder()
        {
            return GetFolder("downloadFolder");
        }
 
        public static string GetSGFolder()
        {
            return GetFolder("SGFolder");
        }
 
        public static string GetPublishFolder()
        {
            return GetFolder("publishFolder");
        }
 
        public static string GetFolder(string key)
        {
            string folder = ConfigurationManager.AppSettings[key];
 
            string path = folder.IndexOf(":\\") > -1 ? folder : Path.Combine(BaseDir, folder);
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
 
            return path;
        }
 
        public static string GetSetting(string key)
        {
            return ConfigurationManager.AppSettings[key];
        }
 
        public static List<DbParameter> GetParams<T>(string sql, T t)
        {
            List<DbParameter> list = new List<DbParameter>();
            Type tType = typeof(T);
            BindingFlags flags = BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance;
 
            int start = sql.IndexOf("@");
            while (start != -1)
            {
                int end = sql.IndexOf(",", start);
                if (end == -1) end = sql.IndexOf(")", start);
                if (end == -1) end = sql.IndexOf(" ", start);
                if (end == -1) end = sql.Length;
 
                string name = sql.Substring(start + 1, end - start - 1);
                PropertyInfo pi = tType.GetProperty(name, flags);
                if (pi != null)
                {
                    object value = pi.GetValue(t, null);
                    DbParameter dp = new NpgsqlParameter("@" + name, value);
                    list.Add(dp);
                }
 
                start = sql.IndexOf("@", end);
            }
 
            return list;
        }
 
        #region * 暂时不用 *
        public static void CreateDirectory(string dir)
        {
            WindowsIdentity wi = WindowsIdentity.GetCurrent();
 
            FileSystemAccessRule rule = new FileSystemAccessRule(wi.User, FileSystemRights.FullControl, AccessControlType.Allow);
            DirectorySecurity ds = new DirectorySecurity();
            ds.AddAccessRule(rule);
 
            Directory.CreateDirectory(dir, ds);
        }
 
        public static T Clone<T>(T source) where T : new()
        {
            if (!typeof(T).IsSerializable)
            {
                throw new ArgumentException("The type must be serializable.", "source");
            }
 
            // Don't serialize a null object, simply return the default for that object
            if (Object.ReferenceEquals(source, null))
            {
                return default(T);
            }
 
            using (Stream stream = new MemoryStream())
            {
                IFormatter formatter = new BinaryFormatter();
                formatter.Serialize(stream, source);
                stream.Seek(0, SeekOrigin.Begin);
 
                return (T)formatter.Deserialize(stream);
            }
        }
        #endregion
    }
}