public Humidity_Air_HIH4000(string Name, bool Simulation, Adc_MCP3208 adc, int channel, Logger Logger)
: base(Name, Simulation, Logger)
{
logger.Debug("Humidity_Air_HIH4000-Constructor_00");
logger = Logger;
logger.Debug("Humidity_Air_HIH4000-Constructor_10");
this.Adc = adc;
logger.Debug("Humidity_Air_HIH4000-Constructor_11");
MinValue = 0;
MaxValue = 100;
AlarmMin = MinValue;
AlarmMax = MaxValue;
voltage = 3.3;
Channel = channel;
firstValue = true;
if (Simulation)
SetFirstValue();
Initialization();
logger.Debug("Humidity_Air_HIH4000-Constructor_99");
}
public CSharpProject(ISolution solution,
Logger logger,
string folderPath,
IFileSystem fileSystem)
: base(fileSystem, logger)
{
_fileSystem = fileSystem;
_logger = logger;
_solution = solution;
Files = new List<CSharpFile>();
References = new List<IAssemblyReference>();
DirectoryInfoBase folder;
try
{
folder = _fileSystem.DirectoryInfo.FromDirectoryName(folderPath);
}
catch (DirectoryNotFoundException)
{
logger.Error("Directory not found - " + folderPath);
return;
}
var files = folder.GetFiles("*.cs", SearchOption.AllDirectories);
foreach (var file in files)
{
_logger.Debug("Loading " + file.FullName);
Files.Add(new CSharpFile(this, file.FullName));
}
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddAssemblyReferences(References)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
AddMsCorlib();
AddReference(LoadAssembly(FindAssembly("System.Core")));
var dlls = folder.GetFiles("*.dll", SearchOption.AllDirectories);
foreach (var dll in dlls)
{
_logger.Debug("Loading assembly " + dll.FullName);
AddReference(dll.FullName);
}
}
public HOOService(object dep)
{
log = new Logger("HOO.SvcLib", this.GetType());
log.Entry.MethodName = "Constructor";
log.Entry.StepName = "Start";
log.Debug(dep.ToString());
if (dep is List<Universe>)
this.World = (List<Universe>)dep;
}
public async Task DebugDoesNotLogWhenLogLevelAtInformation()
{
// Arrange
Logger logger = new Logger(_runtimeEnvironment.Object, _queue.Object, _source.Object, _extension.Object, LogLevelEnum.Information, _correlationIdProvider.Object);
// Act
await logger.Debug("a message");
// Assert
_queue.Verify(x => x.EnqueueAsync(It.IsAny<LogQueueItem>()), Times.Never);
}
public void Debug_WithoutWriter()
{
// arrange
var logger = new Logger();
// act
var ex = Assert.Throws<Exception>(() => logger.Debug("debug message"));
// assert
Assert.Equal("The writer must be set with the 'SetWriter' method first.", ex.Message);
}
public void Debug_WithoutCategoryAdded()
{
// arrange
var logger = new Logger();
var logs = new StringBuilder();
logger.SetWriter(new StringWriter(logs));
// act
logger.Debug("debug message");
// assert
Assert.Equal(string.Empty, logs.ToString());
}
public HouseKeepingHandler(TCPWrapper MyTCPWrapper, MySqlManager MyMySqlManager, Logger MyLogger, errorHandler MyErrorHandler)
{
this.TheLogger = MyLogger;
this.TheMySqlManager = MyMySqlManager;
this.TheTCPWrapper = MyTCPWrapper;
this.TheErrorHandler = MyErrorHandler;
TheTCPWrapper = MyTCPWrapper;
TheMySqlManager = MyMySqlManager;
TheLogger.Debug("New HouseKeepingTimer.Interval: " + this.HouseKeepingTimer.Interval + "\n");
HouseKeepingTimer.Elapsed += new ElapsedEventHandler(HouseKeepingTimer_Tick);
TheTCPWrapper.GotConnected += new TCPWrapper.GotConnectedEventHandler(OnGotConnected);
TheTCPWrapper.GotDisconnected += new TCPWrapper.GotDisconnectedEventHandler(OnGotDisconnected);
}
public void Error()
{
// arrange
var logger = new Logger();
var logs = new StringBuilder();
logger.SetWriter(new StringWriter(logs));
logger.AddCategory("error");
// act
logger.Debug("debug message");
logger.Info("info message");
logger.Error("error message");
// assert
Assert.Equal("error message", logs.ToString().Trim());
}
public void Logger_Debug()
{
const string message = "message";
int counter = 0;
ILogger logger = new Logger();
(logger as Logger).OnCritical = s => Assert.Fail();
(logger as Logger).OnError = s => Assert.Fail();
(logger as Logger).OnWarning = s => Assert.Fail();
(logger as Logger).OnInformational = s => Assert.Fail();
(logger as Logger).OnDebug = s => counter++;
(logger as Logger).OnDiagnostic = s => Assert.Fail();
(logger as Logger).OnChangeEvent = (a, b) => Assert.Fail();
logger.Debug(message);
Assert.AreEqual(1, counter);
}
/// <summary>
/// Costruttore senza ID del sensore, trovato automaticamente dal software
/// Prende il primo termometro che trova
/// </summary>
/// <param name="Name"></param>
/// <param name="Simulation"></param>
/// <param name="Logger"></param>
public Temperature_DS1822(string Name, bool Simulation, Logger Logger)
: base(Name, Simulation, Logger)
{
Logger.Debug("Temperature_DS1822_Constructor senza ID. SensorId automatico");
if (!Simulation)
{
// creazione del termometro; se il parametro DeviceIndex = 0 usa il primo sensore che trova
try
{
termometro = new Ds18b20Connection(0);
}
catch (Exception ex)
{
Logger.Error("Temperature_DS1822_Constructor senza ID. " + ex.Message);
return;
}
}
Initialization();
}
public void TestLogging()
{
var config = new FileConfiguration
{
CreateDateFolder = true,
DaysToKeep = 3,
Path = AppDomain.CurrentDomain.BaseDirectory
};
var target = new FileTarget("Everything", config);
target.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
LoggedType = GetType(),
MethodName = MethodBase.GetCurrentMethod().Name,
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var target2 = new PaddedFileTarget("EVeryone", config);
target2.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
LoggedType = GetType(),
MethodName = MethodBase.GetCurrentMethod().Name,
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var logger = new Logger(GetType(), new[] {target2, target});
logger.Info("Hello");
logger.Debug("Hello");
logger.Warning("Hello");
logger.Error("Hello");
}
public Temperature_DS1822(string Name, bool Simulation, string SensorId,Logger Logger)
: base(Name, Simulation, Logger)
{
Logger.Debug("Temperature_DS1822_Constructor con ID. SensorId: " + SensorId);
// creazione del termometro con l'Id passato
if (!Simulation)
{
try
{
termometro = new Ds18b20Connection(SensorId);
}
catch (Exception ex)
{
Logger.Error("Temperature_DS1822_Constructor con ID. SensorId" + ex.Message);
return;
}
}
IdSensor = SensorId;
Initialization();
}
public AdvertHandler(TCPWrapper MyTCPWrapper, MySqlManager MyMySqlManager, Logger MyLogger, TradeHandler MyTradeHandler, Inventory MyInventory, errorHandler MyErrorHandler)
{
Random RandomClass = new Random();
int i;
this.TheLogger = MyLogger;
this.TheMySqlManager = MyMySqlManager;
this.TheTCPWrapper = MyTCPWrapper;
this.TheTradeHandler = MyTradeHandler;
this.TheInventory = MyInventory;
this.TheErrorHandler = MyErrorHandler;
TheTCPWrapper = MyTCPWrapper;
TheMySqlManager = MyMySqlManager;
TheTCPWrapper.GotCommand += new TCPWrapper.GotCommandEventHandler(OnGotCommand);
if (TheMySqlManager.advertise())
{
this.AdvertTimer.Interval = 1000;
if (TheMySqlManager.advertchannel(Settings.botid) != 99999999)
{
//if (TheMySqlManager.lastadverttime(Settings.botid) + TheMySqlManager.minadverttime() <= DateTime.Now )
if (TheMySqlManager.lastadverttime(Settings.botid) <= TheMySqlManager.minadverttime())
{
i = TheMySqlManager.minadverttime() * 1000;
i += (RandomClass.Next(0, TheMySqlManager.randomadvertdelay()) * 1000);
if (i < 900000)
i = 900000;//minimum 15 minute delay
this.AdvertTimer.Interval = i;
}
}
}
else
{
this.AdvertTimer.Interval = 900000;
}
TheLogger.Debug("New AdvertTimer.Interval: " + this.AdvertTimer.Interval + "\n");
AdvertTimer.Elapsed += new ElapsedEventHandler(AdvertTimer_Tick);
TheTCPWrapper.GotConnected += new TCPWrapper.GotConnectedEventHandler(OnGotConnected);
TheTCPWrapper.GotDisconnected += new TCPWrapper.GotDisconnectedEventHandler(OnGotDisconnected);
}
public void TestLogging()
{
var config = new FileConfiguration
{
CreateDateFolder = true,
DaysToKeep = 3,
Path = @"d:\logfiles"
};
var target = new FileTarget("Everything", config);
target.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
StackFrames = new StackTrace().GetFrames(),
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var target2 = new PaddedFileTarget("EVeryone", config);
target2.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
StackFrames = new StackTrace().GetFrames(),
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var logger = new Logger(GetType(), new[] {target2, target});
logger.Info("Hello");
logger.Debug("Hello");
logger.Warning("Hello");
logger.Error("Hello");
}
public AltAdvertHandler(TCPWrapper MyTCPWrapper, MySqlManager MyMySqlManager, Logger MyLogger, TradeHandler MyTradeHandler, Inventory MyInventory, errorHandler MyErrorHandler)
{
Random RandomClass = new Random();
int i;
this.TheLogger = MyLogger;
this.TheMySqlManager = MyMySqlManager;
this.TheTCPWrapper = MyTCPWrapper;
this.TheTradeHandler = MyTradeHandler;
this.TheInventory = MyInventory;
this.TheErrorHandler = MyErrorHandler;
TheTCPWrapper = MyTCPWrapper;
TheMySqlManager = MyMySqlManager;
uint altadvertchannel = TheMySqlManager.altadvertchannel(Settings.botid);
this.AltAdvertTimer.Interval = 900000;
if (TheMySqlManager.altadvertise())
{
this.AltAdvertTimer.Interval = 1000;
if (altadvertchannel != 99999999)
{
if (TheMySqlManager.lastaltadverttime(Settings.botid) <= TheMySqlManager.minaltadverttime())
{
i = TheMySqlManager.minaltadverttime() * 1000;
i += (RandomClass.Next(0, TheMySqlManager.randomaltadvertdelay()) * 1000);
if (i < 900000)
i = 900000;//minimum 15 minute delay
this.AltAdvertTimer.Interval = i;
}
}
}
TheLogger.Debug("New AltAdvertTimer.Interval: " + this.AltAdvertTimer.Interval + "\n");
if (altadvertchannel != 99999999 && TheMySqlManager.lastaltadverttime(Settings.botid) < TheMySqlManager.minaltadverttime() && MainClass.serverName != "test")
return;
AltAdvertTimer.Elapsed += new ElapsedEventHandler(AltAdvertTimer_Tick);
TheTCPWrapper.GotConnected += new TCPWrapper.GotConnectedEventHandler(OnGotConnected);
TheTCPWrapper.GotDisconnected += new TCPWrapper.GotDisconnectedEventHandler(OnGotDisconnected);
}
public void Execute(Logger log)
{
if (File.Exists(_filePath)) {
using (StreamReader reader = new StreamReader(File.OpenRead(_filePath))) {
_contents.Append(reader.ReadToEnd());
reader.Close();
}
} else {
log.Debug("{1}: File {0} does not exist.", _filePath, Name);
}
}
public void Execute(Logger log)
{
if (File.Exists(_source)) {
if (!File.Exists(_destination)) {
File.Move(_source, _destination);
} else {
string sourceHash = ComputeHash(_source);
if (sourceHash == ComputeHash(_destination)) {
File.Delete(_source);
} else {
string path = Path.GetDirectoryName(_destination);
string file = Path.GetFileNameWithoutExtension(_destination);
string ext = Path.GetExtension(_destination);
for (int i = 1; i < 1000000; i++) {
string numberedDest = string.Format("{0} ({1})", file, i);
string newDest = Path.Combine(path, Path.ChangeExtension(numberedDest, ext));
if (!File.Exists(newDest)) {
File.Move(_source, newDest);
break;
} else if (sourceHash == ComputeHash(newDest)) {
File.Delete(_source);
break;
}
}
}
}
} else {
log.Debug("{1}: File {0} does not exist.", _source, Name);
}
}
public CSharpProject(ISolution solution,
IFileSystem fileSystem,
Logger logger,
string title,
string fileName,
Guid id)
: base(fileSystem, logger)
{
_fileSystem = fileSystem;
_logger = logger;
_solution = solution;
Title = title;
if (fileSystem is FileSystem)
{
fileName = fileName.ForceNativePathSeparator();
}
FileName = fileName;
ProjectId = id;
Files = new List<CSharpFile>();
Microsoft.Build.Evaluation.Project project;
try
{
project = new Microsoft.Build.Evaluation.Project(_fileSystem, fileName);
}
catch (DirectoryNotFoundException)
{
logger.Error("Directory not found - " + FileName);
return;
}
catch (FileNotFoundException)
{
logger.Error("File not found - " + FileName);
return;
}
AssemblyName = project.GetPropertyValue("AssemblyName");
SetCompilerSettings(project);
AddCSharpFiles(project);
References = new List<IAssemblyReference>();
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
AddMsCorlib();
bool hasSystemCore = false;
foreach (var item in project.GetItems("Reference"))
{
var assemblyFileName = GetAssemblyFileNameFromHintPath(project, item);
//If there isn't a path hint or it doesn't exist, try searching
if (assemblyFileName == null)
assemblyFileName = FindAssembly(item.EvaluatedInclude);
//If it isn't in the search paths, try the GAC
if (assemblyFileName == null && PlatformService.IsWindows)
assemblyFileName = FindAssemblyInNetGac(item.EvaluatedInclude);
if (assemblyFileName != null)
{
if (_fileSystem.Path.GetFileName(assemblyFileName).Equals("System.Core.dll", StringComparison.OrdinalIgnoreCase))
hasSystemCore = true;
_logger.Debug("Loading assembly " + item.EvaluatedInclude);
try
{
AddReference(LoadAssembly(assemblyFileName));
}
catch (Exception e)
{
_logger.Error(e);
}
}
else
_logger.Error("Could not find referenced assembly " + item.EvaluatedInclude);
}
if (!hasSystemCore && FindAssembly("System.Core") != null)
AddReference(LoadAssembly(FindAssembly("System.Core")));
AddProjectReferences(project);
}
public void logger_will_not_throw_an_exception_if_one_listener_blows_chunks_for_debug()
{
var l1 = MockRepository.GenerateMock<ILogListener>();
var l2 = MockRepository.GenerateMock<ILogListener>();
var l3 = MockRepository.GenerateMock<ILogListener>();
l1.Stub(x => x.IsDebugEnabled).Return(true);
l2.Stub(x => x.IsDebugEnabled).Return(true);
l3.Stub(x => x.IsDebugEnabled).Return(true);
var logger = new Logger(new ILogListener[] { l1, l2, l3 }, NulloModifiers);
l2.Expect(x => x.Debug("some message")).Throw(new NotSupportedException());
logger.Debug("some message");
l1.AssertWasCalled(x => x.Debug("some message"));
l2.AssertWasCalled(x => x.Debug("some message"));
l3.AssertWasCalled(x => x.Debug("some message"));
}
public CSharpProject(ISolution solution, Logger logger, string folderPath)
{
_logger = logger;
_solution = solution;
Files = new List<CSharpFile>();
References = new List<IAssemblyReference>();
DirectoryInfo folder;
try
{
folder = new DirectoryInfo(folderPath);
}
catch(DirectoryNotFoundException)
{
logger.Error("Directory not found - " + folderPath);
return;
}
var files = folder.EnumerateFiles("*.cs", SearchOption.AllDirectories);
foreach (var file in files)
{
_logger.Debug("Loading " + file.FullName);
Files.Add(new CSharpFile(this, file.FullName));
}
var dlls = folder.EnumerateFiles("*.dll", SearchOption.AllDirectories);
foreach (var dll in dlls)
{
Console.WriteLine(dll.FullName);
AddReference(dll.FullName);
}
AddMsCorlib();
AddReference(LoadAssembly(FindAssembly("System.Core")));
AddAllKpmPackages();
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddAssemblyReferences(References)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
}
void TryLogger(Logger logger)
{
bool thrown = false;
string message = "msg";
try
{
logger.Always(message);
logger.Debug(message);
logger.Detailed(message);
logger.Error(message);
logger.Event(message);
logger.Fatal(message);
logger.Info(message);
logger.Warning(message);
}
catch (Exception)
{
thrown = true;
}
Assert.IsFalse(thrown);
}
public void Logger_NoRoutes()
{
const string message = "message";
ILogger logger = new Logger();
logger.Critical(message);
logger.Error(message);
logger.Warning(message);
logger.Informational(message);
logger.Debug(message);
logger.Diagnostic(message);
logger.ChangeEvent(message, message);//string is not a good example here, but the function isn't called anyway
//yes, nothing happens.
//this test is here to ensure no exceptions occur when leaving handlers unspecified for the logger
}
public void Execute(Logger log)
{
if (File.Exists(_filePath)) {
File.Delete(_filePath);
} else {
log.Debug("{1}: File {0} does not exist.", _filePath, Name);
}
}
/// <summary>
/// Simple test of some ParseUtil methods.
/// </summary>
/// <returns>bool - true for all passed, false otherwise</returns>
public static bool TestSelf()
{
Logger log = new Logger("ParseUtil: TestSelf");
log.Info("Starting...");
StreamTokenizer tokenizer = new StreamTokenizer();
tokenizer.Verbosity = VerbosityLevel.Warn;
// FindMatch
ArrayList alist = new ArrayList();
tokenizer.TokenizeString("{ [ ] '}' }", alist);
foreach(Token t in alist) log.Debug("Token = {0}", t);
Token[] tarray = (Token[])alist.ToArray(typeof(Token));
int i = 0;
if (!FindMatch(tarray, ref i, '{'))
{
log.Error("FindMatch failed to match { char");
return(false);
}
if (i != 4)
{
log.Error("FindMatch got the wrong answer {0}", i);
return(false);
}
else log.Info("FindMatch worked.");
//
// try BuildArray
//
ArrayList tokens = new ArrayList();
tokenizer.TokenizeString("1 2 3 4 5", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
Int16[] shorts = (short[])ParseUtil.BuildArray(tokens, ref i, typeof(Int16), null,
-1, log);
if (shorts == null)
{
log.Error("Unable to BuildArray of shorts.");
return(false);
}
log.Info("Parsed shorts:");
foreach(Int16 s in shorts)
{
log.Write("{0}, ", s);
}
log.WriteLine("");
//
// try BuildArray of floats, char terminated
//
tokens.Clear();
tokenizer.TokenizeString("1 2 ; 3 4", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
Single[] floats = (float[])ParseUtil.BuildArray(tokens, ref i, typeof(Single),
new CharToken(';'), -1, log);
if (floats == null)
{
log.Error("Unable to BuildArray of floats.");
return(false);
}
log.Info("Parsed floats:");
foreach(float f in floats)
{
log.Write("{0}, ", f);
}
log.WriteLine("");
if (i != 2)
{
log.Error("BuildArray left i = {0} which is incorrect");
return(false);
}
//
// try BuildArray on high-precision floats
//
tokens.Clear();
float f1 = 1.23456f;
float f2 = 2.34567f;
tokenizer.TokenizeString(String.Format("{0:f6} {1:f6}", f1,f2), tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
floats = (float[])ParseUtil.BuildArray(tokens, ref i, typeof(Single),
null, -1, log);
if (floats == null)
{
log.Error("Unable to BuildArray of floats.");
return(false);
}
log.Info("Parsed floats:");
foreach(float f in floats)
{
log.Write("{0}, ", f);
}
log.WriteLine("");
if (floats[0] != f1)
{
log.Error("BuildArray produced float {0:f6} instead of {1:f6}",
floats[0], f1);
return(false);
}
//
// try BuildArray of chars, maxLength terminated
//
log.Info("Chars, terminated by maxLength");
tokens.Clear();
tokenizer.TokenizeString("12 2 ; 3 4", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
char[] chars = (char[])ParseUtil.BuildArray(tokens, ref i, typeof(Char),
null, 3, log);
if (chars == null)
{
log.Error("Unable to BuildArray of chars.");
return(false);
}
log.Info("Parsed chars:");
foreach(char f in chars)
{
log.Write("{0}, ", f);
}
log.WriteLine("");
if (i != 4)
{
log.Error("BuildArray left i = {0} which is incorrect", i);
return(false);
}
//
// try BuildArray of hex numbers
//
log.Info("Hex numbers");
tokens.Clear();
tokenizer.Settings.ParseHexNumbers = true;
tokenizer.TokenizeString("0xfff, 0xffe", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
ushort[] ushorts = (ushort[])ParseUtil.BuildArray(tokens, ref i, typeof(ushort),
null, 3, log);
if (ushorts == null)
{
log.Error("Unable to BuildArray of ushorts.");
return(false);
}
log.Info("Parsed ushorts:");
foreach(ushort us in ushorts)
{
log.Write("{0}, ", us);
}
log.WriteLine("");
// if (i != 4)
// {
// log.Error("BuildArray left i = {0} which is incorrect", i);
// return(false);
// }
log.Info("All PASSED");
return(true);
}
public void debug_with_mixed_listeners()
{
var l1 = new RecordingLogListener { IsDebugEnabled = true };
var l2 = new RecordingLogListener { IsDebugEnabled = false, IsInfoEnabled = true };
var l3 = new RecordingLogListener { IsDebugEnabled = true };
var logger = new Logger(SystemTime.Default(), new ILogListener[] { l1, l2, l3 });
logger.Debug("message {0}", 1);
logger.Debug("message {0}", 2);
logger.Debug(() => "message 3");
l1.DebugStrings.ShouldHaveTheSameElementsAs("message 1", "message 2", "message 3");
l3.DebugStrings.ShouldHaveTheSameElementsAs("message 1", "message 2", "message 3");
l2.DebugStrings.Any().ShouldBeFalse();
}
/// <summary>
/// <see cref="INoteManagerService.ListAllUsers"/>
/// </summary>
/// <param name="id"></param>
public UserDTO[] ListAllUsers()
{
Logger logger = new Logger(this.GetType());
logger.Debug("debug");
logger.Error("error");
logger.Info("info");
logger.Warn("warn");
using (var nme = new NoteManagerEntities())
{
var allUsers = from u in nme.User select u;
List<UserDTO> res = new List<UserDTO>();
foreach (var u in allUsers)
{
res.Add(new UserDTO(u));
}
return res.ToArray();
}
}
