小编Ana*_*oly的帖子

根据新的谷歌政治https://googleonlinesecurity.blogspot.de/2014/04/new-security-measures-will-affect-older.html我无法发送电子邮件.对于不使用OAuth 2.0的应用程序,谷歌会考虑"安全性较低的应用程序".

我想使用MailKit来解决这个问题

var message = new MimeMessage();

message.From.Add(new MailboxAddress("Joey Tribbiani", "noreply@localhost.com"));
message.To.Add(new MailboxAddress("Mrs. Chanandler Bong", "mymail@gmail.com"));
message.Subject = "How you doin'?";
message.Body = new TextPart("plain"){ Text = @"Hey" };

using (var client = new SmtpClient())
{
   client.Connect("smtp.gmail.com", 587);

   ////Note: only needed if the SMTP server requires authentication
   client.Authenticate("mymail@gmail.com", "mypassword");

   client.Send(message);
   client.Disconnect(true);
}

但我有 An exception of type 'MailKit.Security.AuthenticationException' occurred in MailKit.dll but was not handled in user code.Additional information: Authentication failed.

我不想更改我的安全设置.因为我希望一切都安全.这就是我开始使用MailKit而不是System.Net.Mail的原因

我该如何解决？

当一个部署项目包含第二个部署项目的项目输出,而第二个项目包含第一个项目的输出时,通常会发生此错误.

我有一个检查循环依赖的方法.在输入中,我们有一个包含,例如,一个词典<"A", < "B", "C" >>和 <"B", < "A", "D" >>,这意味着,A取决于B和C,我们有与循环依赖A->B.

但通常情况下我们会遇到更复杂的情况,并且存在一系列依赖关系.如何修改此方法以查找依赖链？例如,我想要一个包含chain的变量A->B->A,而不是类A与class有冲突B.

private void FindDependency(IDictionary<string, IEnumerable<string>> serviceDependence)

我有一个自定义流,用于直接在页面云blob中执行写入操作.

public sealed class WindowsAzureCloudPageBlobStream : Stream
{
    // 4 MB is the top most limit for page blob write operations
    public const int MaxPageWriteCapacity = 4 * 1024 * 1024;

    // Every operation on a page blob has to manipulate a value which is rounded up to 512 bytes
    private const int PageBlobPageAdjustmentSize = 512;

    private CloudPageBlob _pageBlob;

    public override void Write(byte[] buffer, int offset, int count)
    {
        var additionalOffset = 0;
        var bytesToWriteTotal = count;

        List<Task> list = …

我的程序使用SHA-1证书进行SSL连接.现在,某些Web服务(Gmail)已广泛使用SHA-2证书.这会导致在电子邮件通知设置期间阻止到SMTP服务器的传入连

要发送电子邮件,我使用像这样的SmtpClient

using (var smtpClient = new SmtpClient(serverSettings.SmtpServerName, (int)serverSettings.SmtpPort))
{
     smtpClient.EnableSsl = serverSettings.SmtpUseSsl;
     smtpClient.UseDefaultCredentials = false; 

     if (!string.IsNullOrEmpty(serverSettings.UserName) || !string.IsNullOrEmpty(serverSettings.EncryptedPassword))
     {
          smtpClient.Credentials = new NetworkCredential(serverSettings.UserName, serverSettings.EncryptedPassword);
     }
                ...
      smtpClient.Send(message);
}

我无法使用此代码发送电子邮件,我不想在我的Gmail帐户中允许"安全性较低的应用程序".

如何实现或切换到电子邮件通知的SHA-2证书？

我有以下方法:

public void Write() {
     var tasks = new List<Task>();
     while(...) {
         var memoryStream = new MemoryStream(...);
         var task = _pageBlob.WritePagesAsync(memoryStream, ... );
         tasks.Add(task);
     }    
     Task.WaitAll(tasks.ToArray());
}

如何正确处置memoryStream,在Task？我需要memoryStream在任务完成时处理对象.

边界错误是指程序读取或写入的内存超出分配的内存块的实际尺寸.边界写入错误的示例是将第11个条目写入大小为10的数组中

我有一个必须在my_free()函数实现中检测边界写错误的测试

 int main()
 {   
   const char* string1 = "Hello, this is a string! I exist to demonstrate a common error.";
   char* copy_of_string1 = (char*) my_malloc(strlen(string1));

  // Whoops! Forgot to allocate space for the '\0' that ends the string.
   strcpy(copy_of_string1, string1); // == boundary write error
   my_free(copy_of_string1);

   return 0;
 }

如何捕获用户在分配的块之后直接写入一个或多个零字节的情况？

我现在单独链接列表是由节点组成的,其中每个节点都有一个指向下一个节点的指针(或者是null以结束列表),但是图形也有一个带有数据的节点和指向下一个节点的指针.

那么数据结构Linked List和Graph之间的本质区别是什么？那么基于列表的搜索和基于图形的搜索呢？

malloc(sz) 返回其对齐适用于任何对象的内存.

在32位x86机器上,这意味着返回的地址值malloc()必须可以被4整除.但实际上,32位malloc实现返回8字节对齐的内存,这意味着返回的地址始终可以被8整除.也应该这样做.(在x86-64/IA-64机器上,最大数据对齐为8,但malloc实现返回16字节对齐的内存.)

我对这种情况进行了测试

// Check alignment of returned data.

 int main() 
 {
     double* ptr = (double*) malloc(sizeof(double));
     assert((uintptr_t) ptr % __alignof__(double) == 0);
     assert((uintptr_t) ptr % __alignof__(unsigned long long) == 0);

     char* ptr2 = (char*) malloc(1);
     assert((uintptr_t) ptr2 % __alignof__(double) == 0);
     assert((uintptr_t) ptr2 % __alignof__(unsigned long long) == 0);
  }

我的malloc代码分配的空间比用户请求的多.该空间的第一部分用于存储有关分配的元数据,包括分配的大小.

sizeof(metadata) % 8 == 0

但我的堆

 static char heap[Heap_Capacity];

以不除以8的值开始

metadata* block = (metadata*)heap;
(uintptr_t)block % 8 != 0

我的测试失败了,在这种情况下我该怎么办？如何确保数组以地址开头

metadata* block = (metadata*)heap;
(uintptr_t)block …

我正在编写自己的简单malloc()函数,我想创建更快更有效的变体.我是使用线性搜索并在内存中顺序和连续分配的函数.

改进此算法的下一步是什么？我当前版本的主要缺点是什么？我将非常感谢任何反馈和建议.

typedef struct heap_block
{  
    struct heap_block* next;
    size_t size;
    bool isfree;
}header;

#define Heap_Capacity 100000
static char heap[Heap_Capacity];
size_t heap_size;

void* malloc(size_t sz) 
{
    if(sz == 0 || sz > Heap_Capacity) { return NULL; }

    header* block = (header*)heap;
    if(heap_size == 0)
    {
        set_data_to_block(block, sz);
        return (void*)(block+1);
    }

    while(block->next != NULL) { block = block->next; }

    block->next = (header*)((char*)to_end_data(block) + 8);
    header* new_block = block->next;
    set_data_to_block(new_block, sz);

    return (void*)(new_block+1);
}

void set_data_to_block(header* block, size_t sz)
{ …

我有以下算法来找到两个集合的联合.

IEnumerable<IGroup> labelGroups = _agents.Where(x => settings.LabelIds.Contains(x.Id));
IEnumerable<Guid>labelAgentIds = labelGroups.SelectMany(x => x.AgentIds);

settings.AgentIds = new Collection<Guid>(labelAgentIds.Union(settings.AgentIds).ToList());

要么

IEnumerable<IGroup> labelGroups = _agents.Where(x => settings.LabelIds.Contains(x.Id));
agentIds = labelGroups.Aggregate(agentIds, (current, label) => current.Union(label.AgentIds));

我应该使用哪一个？帮我比较一下这个算法(速度和内存).